@exodus/ethereum-api 8.64.6 → 8.65.0

package/src/tx-log/monitor-utils/get-current-eip7702-delegation.js

@@ -1,38 +1,68 @@
 import { getEIP7702Delegation } from '../../eth-like-util.js'
 
+const NOT_DELEGATED = { isDelegated: false, delegatedAddress: null, isWhitelisted: null }
+
 /**
  * Checks if the address has an EIP-7702 delegation and returns the delegation state.
  * Returns the new state if changed, or the current state if unchanged.
- * On error, returns the current state to preserve existing data.
+ * On error, conservatively returns { isDelegated: false } to avoid showing stale delegation
+ * state that may no longer be accurate.
  *
  * @param {Object} params
  * @param {Object} params.server - The server instance to use for getCode
  * @param {string} params.address - The wallet address to check
+ * @param {Array<{address: string, name: string}>} [params.eip7702Supported] - Whitelist of trusted delegation targets.
+ *   If not an array, the check is skipped entirely (chain does not support EIP-7702).
+ *   An empty array means the check runs but every delegation will be isWhitelisted: false.
  * @param {Object} [params.currentDelegation] - The current delegation state from accountState
  * @param {Object} [params.logger] - Optional logger for warnings
  * @returns {Promise<Object|undefined>} The delegation state to use
  */
-export async function getCurrentEIP7702Delegation({ server, address, currentDelegation, logger }) {
+export async function getCurrentEIP7702Delegation({
+  server,
+  address,
+  eip7702Supported,
+  currentDelegation,
+  logger,
+}) {
+  // Non-array (undefined, false, etc.) → chain doesn't support EIP-7702, skip entirely
+  if (!Array.isArray(eip7702Supported)) return NOT_DELEGATED
+
   try {
     const result = await getEIP7702Delegation({ address, server })
 
-    // Return new state if changed
+    if (!result.isDelegated) return NOT_DELEGATED
+
+    // [] → check runs but nothing is trusted; populated array → whitelist check
+    const isWhitelisted = eip7702Supported.some(
+      ({ address }) => address.toLowerCase() === result.delegatedAddress.toLowerCase()
+    )
+
+    const newDelegation = {
+      isDelegated: true,
+      delegatedAddress: result.delegatedAddress,
+      isWhitelisted,
+    }
+
+    // Return new state only if something changed
     if (
-      currentDelegation?.isDelegated !== result.isDelegated ||
-      currentDelegation?.delegatedAddress !== result.delegatedAddress
+      currentDelegation?.isDelegated !== newDelegation.isDelegated ||
+      currentDelegation?.delegatedAddress !== newDelegation.delegatedAddress ||
+      currentDelegation?.isWhitelisted !== newDelegation.isWhitelisted
     ) {
-      return {
-        isDelegated: result.isDelegated,
-        delegatedAddress: result.delegatedAddress,
-      }
+      return newDelegation
     }
   } catch (error) {
     if (logger) {
       logger.warn('Failed to check EIP-7702 delegation:', error)
     }
+
+    // On error, conservatively clear delegation state — only hard RPC confirmation
+    // should result in isDelegated: true being shown to the user.
+    return NOT_DELEGATED
   }
 
-  // Return current state if unchanged or on error
+  // Return current state if unchanged
   return currentDelegation
 }
 

package/src/tx-send/broadcast-error-handler.js

@@ -0,0 +1,58 @@
+import { EthLikeError, EVM_ERROR_REASONS, getEvmErrorReason } from '../error-wrapper.js'
+import { transactionExists } from '../eth-like-util.js'
+
+/**
+ * Handles broadcast errors by parsing the error message and either throwing
+ * an appropriate EthLikeError or returning info for retry logic.
+ *
+ * @param {Error} err - The error from broadcastTx.
+ * @param {Object} options - Context for error handling.
+ * @param {Object} options.asset - The asset.
+ * @param {string} options.txId - The transaction ID.
+ * @param {boolean} options.isHardware - Whether this is a hardware wallet.
+ * @param {string} options.hint - Hint for the error.
+ * @returns {Promise<{ shouldRetry: boolean }>} - Returns if nonce too low and can retry.
+ * @throws {EthLikeError} - Throws for all other error cases.
+ */
+export const handleBroadcastError = async (err, { asset, txId, isHardware, hint, isBumpTx }) => {
+  const message = err.message
+
+  const errorInfo = getEvmErrorReason(message) || EVM_ERROR_REASONS.broadcastTxFailed
+
+  const isNonceTooLow = errorInfo.reason === EVM_ERROR_REASONS.nonceTooLow.reason
+  const isAmbiguousError =
+    isNonceTooLow || errorInfo.reason === EVM_ERROR_REASONS.transactionUnderpriced.reason
+
+  if (errorInfo.reason === EVM_ERROR_REASONS.alreadyKnown.reason) {
+    console.info('tx already broadcast')
+    return { shouldRetry: false }
+  }
+
+  let txAlreadyExists = false
+  if (isAmbiguousError) {
+    try {
+      txAlreadyExists = await transactionExists({ asset, txId })
+    } catch (verifyErr) {
+      // Can't verify - fall through to original error handling
+      console.warn('Could not verify tx existence:', verifyErr.message)
+    }
+  }
+
+  if (txAlreadyExists) {
+    console.info('tx already broadcast')
+    return { shouldRetry: false }
+  }
+
+  // NOTE: Don't auto-retry nonce repair for bump/replacement txs.
+  // A replacement must keep the *same nonce* as the tx it's replacing.
+  // If we "fix" a bump tx by advancing the nonce, we create a brand-new tx instead of replacing the pending one.
+  if (isNonceTooLow && !isHardware && !isBumpTx) return { shouldRetry: true }
+
+  throw new EthLikeError({
+    message: err.message,
+    errorReasonInfo: errorInfo,
+    hint,
+    traceId: err.traceId,
+    baseAssetName: asset.baseAsset.name,
+  })
+}

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

@@ -1,10 +1,10 @@
 import { normalizeTxId, parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
+import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 
-import * as ErrorWrapper from '../error-wrapper.js'
-import { transactionExists } from '../eth-like-util.js'
 import { getOptimisticTxLogEffects } from '../tx-log/index.js'
 import { ARBITRARY_ADDRESS } from '../tx-type/index.js'
+import { handleBroadcastError } from './broadcast-error-handler.js'
 
 const txSendFactory = ({ assetClientInterface, createTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
@@ -38,6 +38,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
       `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
     )
 
+    // Are there any signin-level errors that should be caught here?
     let { txId, rawTx } = await signTx({
       asset,
       unsignedTx,
@@ -47,41 +48,16 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
     try {
       await baseAsset.api.broadcastTx(rawTx.toString('hex'))
     } catch (err) {
-      const transactionUnderpricedErr = err.message.match(/transaction underpriced/i)
-      const nonceTooLowErr = err.message.match(/nonce (is |)too low/i)
-      const insufficientFundsErr = err.message.match(/insufficient funds/i)
-
-      // NOTE: We've found that `geth` can return the following errors
-      //       for transactions which may be already known. In this
-      //       case, we validate that the transaction is known to the
-      //       network.
-      const txAlreadyExists =
-        nonceTooLowErr || transactionUnderpricedErr
-          ? await transactionExists({ asset, txId })
-          : err.message.match(/already known/i) ||
-            err.message.match(/transaction already imported/i)
-
-      if (txAlreadyExists) {
-        console.info('tx already broadcast') // inject logger factory from platform
-      } else if (insufficientFundsErr) {
-        throw new ErrorWrapper.EthLikeError({
-          message: err.message,
-          reason: ErrorWrapper.reasons.insufficientFunds,
-          hint: 'broadcastTx',
-        })
-      } else if (unsignedTx.txMeta.bumpTxId) {
-        throw new ErrorWrapper.EthLikeError({
-          message: err.message,
-          reason: ErrorWrapper.reasons.bumpTxFailed,
-          hint: 'broadcastTx',
-        })
-      } else if (!nonceTooLowErr) {
-        throw new ErrorWrapper.EthLikeError({
-          message: err.message,
-          reason: ErrorWrapper.reasons.broadcastTxFailed,
-          hint: 'otherErr:broadcastTx',
-        })
-      } else if (nonceTooLowErr && !unsignedTx.txMeta.isHardware) {
+      const isBumpTx = !!unsignedTx.txMeta.bumpTxId
+      const { shouldRetry } = await handleBroadcastError(err, {
+        asset,
+        txId,
+        isHardware: !!unsignedTx.txMeta.isHardware,
+        hint: isBumpTx ? safeString`bumpTx` : safeString`broadcastTx`,
+        isBumpTx,
+      })
+
+      if (shouldRetry) {
         console.info('trying to send again...') // inject logger factory from platform
 
         // let's try to fix the nonce issue
@@ -92,10 +68,9 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
           forceFromNode: true,
         })
 
-        // TODO: We should only do this for non-replacement transactions.
         const triedNonce = parsedTx.nonce
-
-        if (typeof triedNonce === 'number') {
+        // Defensive: avoid retrying the same nonce if node nonce is stale (non-replacement sends only).
+        if (!isBumpTx && typeof triedNonce === 'number') {
           newNonce = Math.max(newNonce, triedNonce + 1)
         }
 
@@ -121,29 +96,15 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
 
         try {
           await baseAsset.api.broadcastTx(rawTx.toString('hex'))
-        } catch (err) {
-          const insufficientFundsErr = err.message.match(/insufficient funds/i)
-          if (insufficientFundsErr) {
-            throw new ErrorWrapper.EthLikeError({
-              message: err.message,
-              reason: ErrorWrapper.reasons.insufficientFunds,
-              hint: 'retry:broadcastTx',
-            })
-          }
-
-          throw new ErrorWrapper.EthLikeError({
-            message: err.message,
-            reason: ErrorWrapper.reasons.broadcastTxFailed,
-            hint: 'retry:broadcastTx',
+        } catch (retryErr) {
+          await handleBroadcastError(retryErr, {
+            asset,
+            txId,
+            isHardware: false,
+            hint: safeString`retry:broadcastTx`,
+            isBumpTx: false, // retry path is only for non-bump anyway
           })
         }
-      } else {
-        // If none of the above apply, terminate with a general error.
-        throw new ErrorWrapper.EthLikeError({
-          message: err.message,
-          reason: ErrorWrapper.reasons.broadcastTxFailed,
-          hint: 'broadcastTx',
-        })
       }
     }