Why Does a Smart Wallet Transaction Show as Success On-Chain but the Dapp Says Failed?

08 October 2026

A wallets/safe-vs-argent-vs-biconomy-smart-wallet/">smart wallet transaction can appear successful on the blockchain while a dapp reports it as failed because the dapp checks a different condition than the one that determines on-chain success. The on-chain transaction completed its execution without reverting, but the dapp’s frontend or logic expects a specific return value, event, or state change that the smart wallet’s interaction did not produce.

How on-chain success works

On the blockchain, a transaction succeeds if it executes without throwing an error or running out of gas. For a smart wallet, this means the wallet’s contract code ran to completion, the required signatures were valid, and any nested calls (such as to a token contract or a protocol) did not revert. The Ethereum Virtual Machine (EVM) records the transaction as successful in the block, and the wallet’s balance or internal state may change accordingly.

For example, if you send a smart wallet transaction to call a swap function on a decentralized exchange, the on-chain success means the swap function was called and returned without error. The wallet’s funds may have been transferred, and the exchange’s state updated.

Why the Dapp Sees a Failure

Dapps do not necessarily rely on the transaction’s on-chain success status. They typically monitor events emitted by the contract they interact with, or they read return values from function calls. A smart wallet transaction can succeed on-chain but fail to emit the expected event, or the return value might not match what the dapp’s frontend expects.

Common Scenarios

1. Emitting an event from a different contract. The dapp may listen for a Transfer event from the token contract it believes you are interacting with. If your smart wallet is performing a complex batched transaction (e.g., approving a token and then swapping), the event might come from a different address or at a different time than the dapp’s frontend is watching. The dapp’s UI may not refresh or may interpret the mismatch as a failure.

2. Return value mismatch. Some dapps call a function and check its return value. If your smart wallet’s transaction succeeds but the return value is false or an unexpected number (e.g., a slippage tolerance was exceeded, but the swap still executed), the dapp’s logic may treat that as a failure. The on-chain transaction did not revert, but the dapp’s frontend sees a condition it considers invalid.

3. Frontend state not updated. Decentralized applications often rely on polling or event listeners that may miss events if the transaction completes quickly or if the UI is not synchronized. A successful transaction may appear failed in the dapp simply because the frontend did not catch the event or refresh the page.

4. Gas estimation or simulation errors. Some dapps pre-simulate transactions to estimate gas or check for reverts. If your smart wallet’s execution path differs from the simulation (e.g., due to a paymaster sponsorship or a different signature validation method like ERC-1271), the dapp might show an error even though the real transaction goes through.

5. Batched transactions with partial failures. Smart wallets often bundle multiple actions into one transaction (e.g., approve and then swap). If the first action succeeds but the second fails, the entire transaction may revert on-chain. However, if the wallet’s contract is designed to handle partial failures (by skipping or ignoring a failed sub-call), the on-chain transaction might still succeed while the dapp only sees the failed sub-call’s result.

How to Diagnose the Issue

• Check the transaction on a block explorer. Look at the transaction receipt to see if any events were emitted, and compare them to what the dapp expects. A missing event is a strong clue.
• Open the dapp’s developer console. Many dapps log errors or warnings when frontend checks fail. These messages often point to the specific condition that was not met.
• Verify the token balances or protocol state. If the transaction was a swap, check your wallet’s token balance on a block explorer or another interface. If the balance changed as intended, the dapp’s failure display is misleading.
• Refresh the dapp or reconnect your wallet. This forces the frontend to re-query the blockchain and update its state.

Why dapps display this incorrectly

The mismatch is a known limitation of how dapps and wallets interact. Dapps are designed around externally owned accounts (EOAs), which have a direct, one-step execution model. Smart wallets introduce complexities like bundling, delegation, and conditional execution that the dapp’s frontend may not handle correctly. The on-chain result is always authoritative, regardless of what the dapp’s UI shows. If the transaction succeeded on-chain, your intended actions (e.g., token swap, deposit) likely occurred, even if the dapp says otherwise.

Back to smart wallets