[Sentry] Error: Cannot add another deeplink transaction

[sentry]

Sentry Issue: METAMASK-MOBILE-3XHT

Error: Cannot add another deeplink transaction
  at ResultError (ses-hermes.cjs:9515:17)
  at _addTransactionForDeeplink (app/components/Views/confirmations/utils/deeplink.ts:71:22)
  at e.addTransactionForDeeplink (app/components/Views/confirmations/utils/deeplink.ts:60:48)
  at _handleEthereumUrl (app/core/DeeplinkManager/Handlers/handleEthereumUrl.ts:52:13)
  at _e.default (app/core/DeeplinkManager/Handlers/handleEthereumUrl.ts:17:33)
...
(45 additional frame(s) were not displayed)

[dan437]

@cursor Analyze this MetaMask issue and provide:

1. Problem: What's broken (2-3 sentences)
2. Root Cause: 1-2 likely causes based on evidence
3. Target Repo(s): Which repo needs the fix (this repo/core/transaction-controller/other controllers in the core repo)
4. Solutions: 2-3 approaches with pros/cons, recommend the best one
5. Impact: Severity + complexity estimate

[cursor]

Create PR

Analysis of MetaMask Deeplink Transaction Error

1. Problem

The app uses a module-level flag isAddingDeeplinkTransaction to prevent concurrent deeplink transaction requests. When an error occurs during transaction processing (via addTransaction()), the flag is never reset to false, permanently blocking all subsequent deeplink transactions. Users then see "Cannot add another deeplink transaction" on every deeplink attempt until they restart the app.

2. Root Cause

Primary cause: Missing error handling in addTransactionForDeeplink() function:

  // Temporary solution for preventing back to back deeplink requests
  if (isAddingDeeplinkTransaction) {
    Logger.error(new Error('Cannot add another deeplink transaction'));
    return;
  }

  isAddingDeeplinkTransaction = true;

  const selectedAccountAddress =
    AccountsController.getSelectedAccount().address;

  let chainId: Hex;
  if (chain_id) {
    chainId = toHex(chain_id as string);
  } else {
    // Deeplinks are fallback to mainnet rather than the selected network
    chainId = CHAIN_IDS.MAINNET;
  }

  const networkClientId = getNetworkClientIdForChainId(chainId);
  const from = safeToChecksumAddress(selectedAccountAddress) as string;
  const to = safeToChecksumAddress(target_address);
  const checkSummedParamAddress = safeToChecksumAddress(
    parameters?.address ?? '',
  );

  if (function_name === ETH_ACTIONS.TRANSFER) {
    // ERC20 transfer
    const txParams: TransactionParams = {
      from,
      to,
      data: generateTransferData('transfer', {
        toAddress: checkSummedParamAddress,
        amount: toHex(parameters?.uint256 as string),
      }),
    };

    await addTransaction(txParams, {
      networkClientId,
      origin,
      type: TransactionType.tokenMethodTransfer,
    });
  } else {
    // Native transfer
    const txParams: TransactionParams = {
      from,
      to,
      value: toHex(parameters?.value as string),
    };

    await addTransaction(txParams, {
      networkClientId,
      origin,
      type: TransactionType.simpleSend,
    });
  }

  isAddingDeeplinkTransaction = false;

The flag is set at line 75 but only reset at line 126. If addTransaction() throws (lines 106 or 120), the function exits without reaching line 126.

Secondary cause: The comment on line 56-57 indicates this is a "temporary solution" and suggests the underlying issue is that DeeplinkManager.parse is being called multiple times per request.

3. Target Repo(s)

This repository (metamask-mobile) - The bug is in the mobile app's deeplink handling layer. While the transaction-controller could potentially add its own deduplication, the immediate fix belongs here.

4. Solutions

Option A: Add try-finally block (RECOMMENDED)

isAddingDeeplinkTransaction = true;
try {
  // ... existing transaction logic ...
  await addTransaction(txParams, options);
} finally {
  isAddingDeeplinkTransaction = false;
}

Pros: Simple, minimal change, preserves existing behavior, ensures flag always resets
Cons: Doesn't address root cause (duplicate parse calls)

Option B: Remove flag entirely + fix duplicate parse calls

// Remove isAddingDeeplinkTransaction entirely
// Fix DeeplinkManager to call parse() once per request

Pros: Addresses root cause, cleaner architecture
Cons: Higher complexity, requires investigation of DeeplinkManager flow, higher risk

Option C: Time-based flag with auto-reset

let deeplinkLockTimestamp = 0;
const LOCK_TIMEOUT = 5000; // 5 seconds

if (Date.now() - deeplinkLockTimestamp < LOCK_TIMEOUT) {
  Logger.error(new Error('Cannot add another deeplink transaction'));
  return;
}
deeplinkLockTimestamp = Date.now();

Pros: Self-healing, handles edge cases
Cons: Arbitrary timeout, doesn't fix underlying issue, could mask real problems

Recommendation: Option A - It's the safest immediate fix with minimal risk. Follow up with Option B once you investigate why parse() is being called multiple times.

5. Impact

Severity: HIGH - Once triggered, users cannot process any deeplinks until app restart. Based on Sentry tracking, this is hitting production users.

Complexity: LOW (for Option A) - 5-line change wrapping the transaction logic in try-finally block

Estimated effort: 15 minutes to fix + test, 1 hour for comprehensive testing across different deeplink scenarios

---

 

_{Learn more about Cursor Agents}

[OGPoyraz]

This is a false positive. I cannot link the message but posted this previously on mobile development channel because it got deleted because of retention policy.

But the reason is when a deeplink request hits in to the app - DeeplinkManager calls addTransactionForDeeplink twice. And this is exactly why that is triggering this error. I will decrease it to debug instead of an error.