@exodus/ethereum-api 8.75.0 → 8.75.1

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.75.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.75.0...@exodus/ethereum-api@8.75.1) (2026-05-19)
+
+
+### Bug Fixes
+
+
+* fix: use correct fromAddress for gasLimit multiplication (#8078)
+
+
+
 ## [8.75.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.74.1...@exodus/ethereum-api@8.75.0) (2026-05-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.75.0",
+  "version": "8.75.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",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "8cf5e6a5fc7d235c2c57ea51219bb1e3469329c5"
+  "gitHead": "ee5bf2d01055d8822c6421fa0ad4da84d4a33402"
 }

package/src/allowance/index.js

@@ -120,11 +120,9 @@ export const buildLegacyApproveTx = async ({
   const baseAsset = asset.baseAsset
 
   return {
-    asset: baseAsset.name,
-    receiver: {
-      address: unsignedTx.txData.to,
-      amount: buffer2currency({ asset: baseAsset, value: unsignedTx.txData.value }),
-    },
+    asset: baseAsset,
+    address: unsignedTx.txData.to,
+    amount: buffer2currency({ asset: baseAsset, value: unsignedTx.txData.value }),
     txInput: unsignedTx.txData.data,
     gasPrice: buffer2currency({ asset: baseAsset, value: unsignedTx.txData.gasPrice }),
     tipGasPrice: unsignedTx.txData.tipGasPrice
@@ -132,13 +130,12 @@ export const buildLegacyApproveTx = async ({
       : undefined,
     gasLimit: bufferToInt(unsignedTx.txData.gasLimit),
     fromAddress: unsignedTx.txMeta.fromAddress,
-    silent: true,
   }
 }
 
 // @deprecated use buildApproveTx instead
 export const createApprove =
-  ({ assetClientInterface, sendTx }) =>
+  ({ assetClientInterface } = Object.create(null)) =>
   async ({
     spenderAddress,
     asset,
@@ -164,7 +161,16 @@ export const createApprove =
         walletAccount,
       })
 
-      const txData = await sendTx({ walletAccount, ...approveTx, ...extras })
+      const { unsignedTx } = await asset.baseAsset.api.createTx({
+        walletAccount,
+        ...approveTx,
+        ...extras,
+      })
+      const txData = await asset.baseAsset.api.sendTx({
+        asset: asset.baseAsset,
+        walletAccount,
+        unsignedTx,
+      })
 
       if (!txData || !txData.txId) {
         throw new Error(`Failed to approve ${asset.displayTicker} - ${spenderAddress}`)
@@ -185,25 +191,20 @@ export const createApprove =
       walletAccount,
     })
 
-    const { txId, rawTx } = await assetClientInterface.signTransaction({
-      assetName: asset.baseAsset.name,
-      unsignedTx,
-      walletAccount,
-    })
+    const { txId } = await asset.baseAsset.api.sendTx({ asset, walletAccount, unsignedTx })
 
-    await asset.baseAsset.api.broadcastTx(rawTx.toString('hex'))
     return { txId }
   }
 
 const createSendApprovalAndWatchConfirmation =
-  ({ sendTx, watchTxConfirmation }) =>
+  ({ watchTxConfirmation }) =>
   async (data) => {
     // To change the approve amount you first have to reduce the addresses`
     // allowance to zero by calling `approve(_spender, 0)` if it is not
     // already 0 to mitigate the race condition described here:
     // see: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     // see: https://etherscan.io/address/0xdac17f958d2ee523a2206206994597c13d831ec7#code
-    const approve = createApprove({ sendTx })
+    const approve = createApprove()
     const { txId } = await approve(data)
     await watchTxConfirmation(
       { asset: data.asset.baseAsset.name, walletAccount: data.walletAccount },
@@ -215,11 +216,10 @@ const createSendApprovalAndWatchConfirmation =
   }
 
 export const createApproveSpendingTokens =
-  ({ sendTx, watchTxConfirmation }) =>
+  ({ watchTxConfirmation }) =>
   async (data) => {
     const txIds = []
     const sendApprovalAndWatchConfirmation = createSendApprovalAndWatchConfirmation({
-      sendTx,
       watchTxConfirmation,
     })
     if (ZERO_ALLOWANCE_ASSETS.includes(data.asset.name) && !data.approveAmount.isZero) {
@@ -235,7 +235,7 @@ export const createApproveSpendingTokens =
       data.gasLimit = Math.max(data.gasLimit || 0, APPROVAL_GAS_LIMIT)
     }
 
-    const tokenApprovalTxId = await sendApprovalAndWatchConfirmation({ ...data, sendTx })
+    const tokenApprovalTxId = await sendApprovalAndWatchConfirmation(data)
     txIds.push(tokenApprovalTxId)
 
     return txIds

package/src/create-asset-utils.js

@@ -12,7 +12,9 @@ import { ClarityMonitorV2 } from './tx-log/clarity-monitor-v2.js'
 import { ClarityTruncatedHistoryMonitor } from './tx-log/clarity-truncated-history-monitor.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
+import { getOptimisticTxLogEffects } from './tx-log/get-optimistic-txlog-effects.js'
 import { BLOCK_TAG_LATEST, BLOCK_TAG_PENDING, resolveNonce } from './tx-send/nonce-utils.js'
+import { signTx } from './tx-sign/index.js'
 
 // Determines the appropriate `monitorType`, `serverUrl` and `monitorInterval`
 // to use for a given config.
@@ -121,7 +123,126 @@ const broadcastPrivateBundleFactory =
     return null
   }
 
-export const createTransactionPrivacyFactory = ({ assetName, privacyRpcUrl }) => {
+const assertSendPrivateTxProps = ({ asset, unsignedTx, walletAccount }) => {
+  assert(asset, 'expected asset')
+  assert(unsignedTx, 'expected unsignedTx')
+  assert(walletAccount, 'expected walletAccount')
+}
+
+export const createTransactionPrivacyResult = ({
+  assetClientInterface,
+  broadcastPrivateBundle,
+  broadcastPrivateTx,
+  privacyServer,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(typeof broadcastPrivateBundle === 'function')
+  assert(typeof broadcastPrivateTx === 'function')
+  assert(privacyServer, 'expected privacyServer')
+
+  const sendPrivateTx = async ({ asset, unsignedTx, walletAccount }) => {
+    assertSendPrivateTxProps({ asset, unsignedTx, walletAccount })
+
+    const { rawTx, txId } = await signTx({
+      asset,
+      assetClientInterface,
+      unsignedTx,
+      walletAccount,
+    })
+
+    await broadcastPrivateTx(rawTx.toString('hex'))
+
+    const fromAddress = unsignedTx.txMeta?.fromAddress
+    assert(typeof fromAddress === 'string', 'expected fromAddress')
+
+    const { nonce, optimisticTxLogEffects } = await getOptimisticTxLogEffects({
+      asset,
+      assetClientInterface,
+      fromAddress,
+      txId,
+      unsignedTx,
+      walletAccount,
+    })
+
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
+    }
+
+    return { nonce, txId }
+  }
+
+  const sendPrivateBundle = async ({ unsignedTxBundle }) => {
+    assert(
+      Array.isArray(unsignedTxBundle) && unsignedTxBundle.length > 0,
+      'expected non-empty unsignedTxBundle'
+    )
+
+    unsignedTxBundle.forEach(assertSendPrivateTxProps)
+
+    const signTxResults = await Promise.all(
+      unsignedTxBundle.map(({ asset, unsignedTx, walletAccount }) =>
+        signTx({ assetClientInterface, asset, unsignedTx, walletAccount })
+      )
+    )
+
+    const maybeBundleResult = await broadcastPrivateBundle({
+      txs: signTxResults.map(({ rawTx }) => rawTx.toString('hex')),
+    })
+
+    const bundleHash = maybeBundleResult?.bundleHash || undefined
+
+    const getOptimisticTxLogEffectsResults = []
+
+    for (const [i, { txId }] of signTxResults.entries()) {
+      const { asset, unsignedTx, walletAccount } = unsignedTxBundle[i]
+
+      const fromAddress = unsignedTx.txMeta?.fromAddress
+      assert(typeof fromAddress === 'string', 'expected fromAddress')
+
+      void getOptimisticTxLogEffectsResults.push(
+        await getOptimisticTxLogEffects({
+          asset,
+          assetClientInterface,
+          fromAddress,
+          txId,
+          unsignedTx,
+          walletAccount,
+          // TODO: use consistent naming
+          bundleId: bundleHash,
+        })
+      )
+    }
+
+    const optimisticTxLogEffects = getOptimisticTxLogEffectsResults.flatMap(
+      ({ optimisticTxLogEffects }) => optimisticTxLogEffects
+    )
+
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
+    }
+
+    return {
+      bundleHash,
+      txIds: signTxResults.map(({ txId }) => txId),
+    }
+  }
+
+  return {
+    broadcastPrivateBundle,
+    broadcastPrivateTx,
+    privacyServer,
+    sendPrivateTx,
+    sendPrivateBundle,
+  }
+}
+
+export const createTransactionPrivacyFactory = ({
+  assetClientInterface,
+  assetName,
+  privacyRpcUrl,
+}) => {
+  assert(assetClientInterface, 'expected assetClientInterface')
+
   if (!privacyRpcUrl) return Object.create(null)
 
   const privacyServer = createEvmServer({
@@ -130,11 +251,16 @@ export const createTransactionPrivacyFactory = ({ assetName, privacyRpcUrl }) =>
     monitorType: 'no-history',
   })
 
-  return {
-    broadcastPrivateBundle: broadcastPrivateBundleFactory({ privacyServer }),
-    broadcastPrivateTx: (...args) => privacyServer.sendRawTransaction(...args),
+  const broadcastPrivateBundle = broadcastPrivateBundleFactory({ privacyServer })
+
+  const broadcastPrivateTx = (...args) => privacyServer.sendRawTransaction(...args)
+
+  return createTransactionPrivacyResult({
+    assetClientInterface,
+    broadcastPrivateBundle,
+    broadcastPrivateTx,
     privacyServer,
-  }
+  })
 }
 
 export const createHistoryMonitorFactory = ({

package/src/create-asset.js

@@ -195,11 +195,17 @@ export const createAssetFactory = ({
       server,
     })
 
-    const { broadcastPrivateBundle, broadcastPrivateTx, privacyServer } =
-      createTransactionPrivacyFactory({
-        assetName: asset.name,
-        privacyRpcUrl,
-      })
+    const {
+      broadcastPrivateBundle,
+      broadcastPrivateTx,
+      privacyServer,
+      sendPrivateTx,
+      sendPrivateBundle,
+    } = createTransactionPrivacyFactory({
+      assetClientInterface,
+      assetName: asset.name,
+      privacyRpcUrl,
+    })
 
     const features = {
       accountState: true,
@@ -354,16 +360,18 @@ export const createAssetFactory = ({
       chainId,
       monitorType,
       estimateL1DataFee,
-      broadcastPrivateBundle,
-      broadcastPrivateTx,
       forceGasLimitEstimation,
       eip7702Supported,
       getEIP7702Delegation: (addr) => getEIP7702Delegation({ address: addr, server }),
       getNonce,
-      privacyServer,
       server,
       ...(erc20FuelBuffer && { erc20FuelBuffer }),
       ...(fuelThreshold && { fuelThreshold: asset.currency.defaultUnit(fuelThreshold) }),
+      broadcastPrivateBundle,
+      broadcastPrivateTx,
+      privacyServer,
+      sendPrivateTx,
+      sendPrivateBundle,
     }
     return overrideCallback({
       asset: fullAsset,

package/src/gas-estimation.js

@@ -157,7 +157,7 @@ export async function fetchGasLimit({
   const gasLimitMultiplier = await resolveGasLimitMultiplier({
     asset,
     feeData,
-    fromAddress: providedFromAddress,
+    fromAddress,
     toAddress: txToAddress,
   })
 

package/src/staking/ethereum/service.js

@@ -66,7 +66,6 @@ import NumberUnit from '@exodus/currency'
 import assert from 'minimalistic-assert'
 
 import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
-import { getOptimisticTxLogEffects } from '../../tx-log/get-optimistic-txlog-effects.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'
@@ -281,8 +280,6 @@ export function createEthereumStakingService({
       asset,
       fromAddress: delegatorAddress,
       walletAccount,
-      tag: 'latest',
-      forceFromNode: true,
     })
 
     return {
@@ -369,14 +366,12 @@ export function createEthereumStakingService({
         plan: null,
         gasLimit: null,
         unsignedTx: null,
-        signedTx: null,
         txId: null,
       },
       undelegate: {
         plan: null,
         gasLimit: null,
         unsignedTx: null,
-        signedTx: null,
         txId: null,
       },
     }
@@ -465,34 +460,16 @@ export function createEthereumStakingService({
       revertOnSimulationError,
     })
 
-    // 4. Sign transactions
-    const signedTxEntries = await Promise.all(
-      Object.entries(txSteps)
-        .filter(([, txStep]) => txStep.unsignedTx)
-        .map(async ([key, txStep]) => {
-          const signedTx = await assetClientInterface.signTransaction({
-            assetName: asset.baseAsset.name,
-            unsignedTx: txStep.unsignedTx,
-            walletAccount,
-          })
-          const txId = `0x${signedTx.txId.toString('hex')}`
-          return [key, { signedTx, txId }]
-        })
-    )
-
-    for (const [key, { signedTx, txId }] of signedTxEntries) {
-      txSteps[key].signedTx = signedTx
-      txSteps[key].txId = txId
-    }
+    const unsignedTxBundle = createdTxEntries.map(([_, unsignedTx]) => ({
+      asset,
+      unsignedTx,
+      walletAccount,
+    }))
 
+    // 4. Sign transactions
+    //
     // 5. Broadcast transactions via bundle and get bundle hash
-    const bundleResponse = await asset.broadcastPrivateBundle({
-      txs: Object.values(txSteps)
-        .filter((txStep) => txStep.signedTx)
-        .map(({ signedTx }) => signedTx.rawTx),
-    })
-    const bundleHash = bundleResponse?.bundleHash
-
+    //
     // 6. Optimistic tx-log effects: reflect tx presence and fee consumption only.
     // The ETH returned to the user via the contract's internal transfer is not
     // captured here — it will be picked up once the tx is confirmed on-chain.
@@ -518,26 +495,14 @@ export function createEthereumStakingService({
     // That is incompatible with the current tx-log side-effect hook, which only
     // receives tx-local data (method id, calldata, nonce, gas, etc.) and not
     // staking snapshots or precomputed ETH-return amounts.
-    const optimisticEffects = await Promise.all(
-      Object.values(txSteps)
-        .filter((txStep) => txStep.txId)
-        .map((txStep) =>
-          getOptimisticTxLogEffects({
-            asset: asset.baseAsset,
-            assetClientInterface,
-            fromAddress: delegatorAddress,
-            txId: txStep.txId,
-            unsignedTx: txStep.unsignedTx,
-            walletAccount,
-            bundleId: bundleHash ?? undefined,
-          })
-        )
-    )
+    const {
+      bundleHash,
+      txIds: [...txIds],
+    } = await asset.baseAsset.sendPrivateBundle({ unsignedTxBundle })
 
-    for (const { optimisticTxLogEffects } of optimisticEffects) {
-      for (const effect of optimisticTxLogEffects) {
-        await assetClientInterface.updateTxLogAndNotify(effect)
-      }
+    for (const txStep of Object.values(txSteps)) {
+      if (!txStep.unsignedTx) continue
+      assert((txStep.txId = txIds.shift()), 'expected txId')
     }
 
     // Testnet assets do not support delegations tracking
@@ -770,7 +735,7 @@ export function createEthereumStakingService({
     waitForConfirmation = false,
     feeData,
   }) {
-    const sendTxArgs = {
+    const { unsignedTx } = await asset.baseAsset.api.createTx({
       asset,
       walletAccount,
       address: to,
@@ -781,9 +746,9 @@ export function createEthereumStakingService({
       // HACK: Override the `tipGasPrice` to use a custom `maxPriorityFeePerGas`.
       tipGasPrice,
       feeData,
-    }
+    })
 
-    const { txId } = await asset.baseAsset.api.sendTx(sendTxArgs)
+    const { txId } = await asset.baseAsset.api.sendTx({ asset, walletAccount, unsignedTx })
 
     const baseAsset = asset.baseAsset
     if (waitForConfirmation) {

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

@@ -1,8 +1,9 @@
-import { normalizeTxId, parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
+import { parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
 import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 
 import { getOptimisticTxLogEffects } from '../tx-log/index.js'
+import { signTx } from '../tx-sign/index.js'
 import { ARBITRARY_ADDRESS } from '../tx-type/index.js'
 import { handleBroadcastError } from './broadcast-error-handler.js'
 
@@ -10,16 +11,6 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(createTx, 'createTx is required')
 
-  async function signTx({ asset, unsignedTx, walletAccount }) {
-    const { rawTx, txId } = await assetClientInterface.signTransaction({
-      assetName: asset.baseAsset.name,
-      unsignedTx,
-      walletAccount,
-    })
-
-    return { rawTx, txId: normalizeTxId(txId) }
-  }
-
   return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
     const baseAsset = asset.baseAsset
 
@@ -41,6 +32,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
     // Are there any signin-level errors that should be caught here?
     let { txId, rawTx } = await signTx({
       asset,
+      assetClientInterface,
       unsignedTx,
       walletAccount,
     })
@@ -92,7 +84,12 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
           unsignedTx.txData.nonce = newNonce
         }
 
-        ;({ txId, rawTx } = await signTx({ asset, unsignedTx, walletAccount }))
+        ;({ txId, rawTx } = await signTx({
+          asset,
+          assetClientInterface,
+          unsignedTx,
+          walletAccount,
+        }))
 
         try {
           await baseAsset.api.broadcastTx(rawTx.toString('hex'))

package/src/tx-sign/index.js

@@ -0,0 +1,17 @@
+import { normalizeTxId } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+export const signTx = async ({ asset, assetClientInterface, unsignedTx, walletAccount }) => {
+  assert(asset, 'expected asset')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(unsignedTx, 'expected unsignedTx')
+  assert(walletAccount, 'expected walletAccount')
+
+  const { rawTx, txId } = await assetClientInterface.signTransaction({
+    assetName: asset.baseAsset.name,
+    unsignedTx,
+    walletAccount,
+  })
+
+  return { rawTx, txId: normalizeTxId(txId) }
+}