A trader executes a swap on Uniswap, expecting to receive 10 ETH for a large stablecoin position. The transaction enters the mempool. Within seconds, a MEV bot or flash loan attack detects the incoming trade, front-runs it with its own liquidity drain, and the user’s transaction executes at a drastically worse price—receiving only 8.5 ETH instead of the promised amount. The difference vanishes into slippage, sandwich attacks, or worse. By the time the transaction confirms, the damage is done and the user has no clear visibility into what happened or why the outcome diverged so sharply from expectation.

This scenario has become routine on high-volume decentralized exchanges, yet most wallet software continues to show only the input amount and a nominal exchange rate. The actual output depends on network conditions, liquidity depth, and hostile transaction ordering—none of which are visible until the transaction is already final. Rabby Wallet’s approach is fundamentally different. Its transaction simulation and balance preview system execute the intended swap in a local simulation before the user signs, displaying the exact output, the fees involved, and the actual price impact. For swap-heavy traders, that pre-sign visibility transforms a blind commitment into an informed choice. Understanding how the system works, its technical boundaries, and its limitations is essential for anyone relying on it to manage meaningful positions.

How transaction simulation creates an on-chain preview before signing

The core mechanic is deceptively simple: before a user signs a transaction, Rabby sends a copy of it to a blockchain node as a static call or dry run. This simulation does not broadcast the transaction or consume gas. Instead, it executes the code path—the smart contract logic, the liquidity pools, the state changes—as if the transaction were being mined, capturing the output without committing it to the chain. For a Uniswap swap, this means the simulation calculates the exact amount of output tokens, applies the current slippage formula, accounts for protocol fees, and returns the result.

This approach differs fundamentally from displaying a quoted rate or a 0.5% slippage tolerance. Those methods require the user to trust that market conditions will remain stable between the time the quote is issued and the time the transaction mines. A simulation, by contrast, reads the current state of the blockchain—the liquidity in the pools, the token balances, the fee tiers—and computes the precise output for the exact transaction about to be signed. The window of uncertainty shrinks from “seconds or minutes” to “the next block.”

The transaction simulation feature in Rabby also interprets what the transaction will do in human-readable terms. Rather than showing raw contract calls, it displays “Swap 100 USDC for 0.055 ETH” or “Approve Uniswap Router to spend USDC.” When the user opens the transaction preview, they see the balance changes: tokens leaving the wallet, tokens arriving, any intermediate steps. This interpretation layer is critical because it catches mismatches between intent and code—a user intending to swap might accidentally be approving an unlimited token allowance instead, and the preview makes that visible before signing.

For a swap-heavy trader moving significant volume daily, this simulation happens for every transaction. Each time the user initiates a trade on Uniswap, SushiSwap, Curve, or another DEX accessible through Rabby, the wallet downloads the current blockchain state, executes the trade logic locally, and shows the outcome. If network conditions have shifted—if large trades have hit the pool since the user opened the DEX interface—the simulation reflects that reality. The user can then choose to proceed, adjust the slippage tolerance and retry, or cancel.

Detecting slippage manipulation and sandwich attacks through balance preview

Slippage on a DEX is the difference between the expected output and the actual output, caused by price impact, fees, and timing. A user setting 0.5% maximum slippage on a large swap is saying “execute this trade only if I receive at least 99.5% of the theoretical output.” But that tolerance is a safety rail, not a guarantee. If the pool has been drained by another transaction or if a MEV searcher has already front-run the order, the slippage may exceed the limit and the transaction will revert—or it may succeed but at an unfavorable price.

Rabby’s balance preview makes that scenario visible before the user signs. When a trader previews a swap, the wallet shows not only the output amount but also the implied price, the percentage slippage relative to spot price, and any fees. If the balance preview shows “Receive 8.5 ETH after 15% slippage,” that number is concrete. The user is not guessing whether their transaction will receive 10 ETH or 8.5; they are seeing what will actually happen on-chain given the current state. If that outcome is unacceptable, they can cancel, adjust the slippage tolerance lower, or split the trade into smaller pieces.

The real protection against sandwich attacks emerges from this transparency. A sandwich attack works by obscuring the true execution price: the attacker front-runs a trade, inflates the price, lets the victim’s transaction execute at that inflated price, and then back-runs it to profit from the reversal. Rabby’s simulation does not prevent the attack—that would require mempool privacy, which a browser extension cannot provide—but it does eliminate the surprise. When the user previews the transaction, they see the slippage value that will be incurred. If a MEV bot has already queued a front-running trade, the simulation will reflect the degraded price and flag it. The user can then decide whether to accept that cost, wait for lower-congestion periods, or use a MEV-resistant service like MEV-Blocker or MEV-Burn.

This is why the balance preview is particularly valuable for large swaps. A $10,000 trade on Uniswap with low liquidity in a pair might incur 3–5% slippage naturally; if the pool is also being attacked, the actual slippage could spike to 8–10%. A trader relying only on the DEX interface’s quoted rate might not notice the difference until the transaction confirms. Rabby’s simulation surfaces that gap immediately, converting an invisible cost into a visible choice.

Flash loan detection through transaction interpretation

A flash loan attack exploits a vulnerability in a smart contract by borrowing a large amount of liquidity within a single transaction, manipulating state, and repaying the loan plus a small fee within the same block. The attack is atomic—it either succeeds completely or reverts entirely, leaving no trace on-chain if it fails. However, successful flash loans leave signatures in the transaction’s state changes, and Rabby’s transaction interpreter can flag suspicious patterns.

When a swap transaction is simulated, Rabby’s system examines not just the direct token transfers but also the contract interactions and state mutations. A normal Uniswap swap involves a user sending tokens to the DEX contract, the DEX swapping internally, and the output being returned. A transaction that first calls an external contract, executes a swap at an artificial price, and then manipulates the state in a way that would not occur under normal market conditions may indicate a flash loan attack or a similar exploit.

The wallet cannot prevent a flash loan attack that is directed at another user’s transaction or at a smart contract’s logic. It can, however, alert the user to unusual patterns. If a trader is about to sign a transaction that interacts with a contract that has previously been exploited, or that involves several state-changing calls in sequence, Rabby’s risk alerts system can flag the behavior. The alert does not block the transaction; instead, it surfaces the unusual elements so the user can review them carefully.

More concretely, if a user attempts to swap through a DEX that has just been hit by a flash loan exploit or that has unusual liquidity conditions, the simulation will show a drastically different output than the user expected. A swap that should yield 1 ETH but instead yields 0.5 ETH will be immediately visible in the balance preview. That visibility alone—without needing to understand flash loans or MEV mechanics—prompts the user to pause and reconsider whether the transaction is legitimate.

Price oracle attacks and the limits of simulation

Not all on-chain risks can be caught by transaction simulation, and understanding the boundaries is critical. A price oracle attack occurs when an attacker manipulates the price feed that a smart contract uses to make decisions. If a lending protocol relies on Uniswap’s time-weighted average price (TWAP) to determine collateral value, an attacker can execute large swaps to move the price, borrow against inflated collateral, and profit when the price normalizes. The transaction itself may look legitimate in Rabby’s simulation.

The reason is that simulation executes the transaction against the current blockchain state but cannot predict how other transactions in the same block or future blocks will affect prices. If a trader’s swap is the first transaction in a block, the simulation is accurate for that moment. But if another transaction executes first, the state changes, and the actual outcome will differ. Rabby mitigates this by checking the simulation result against the transaction’s slippage tolerance: if the tolerance is set to 1% and the simulation shows 2% slippage, the wallet will warn the user. However, this check is only as good as the tolerance itself.

For users interacting with yield farming protocols, lending platforms, or complex derivative contracts that depend on price feeds, the risks extend beyond DEX slippage. A contract that claims to offer 50% APY might be vulnerable to oracle manipulation or rug pull. Rabby’s transaction preview will show the tokens being sent and the mechanism being called, but it will not assess whether the protocol is fundamentally solvent or whether the returns are sustainable. The wallet can interpret and simulate the transaction; it cannot audit the protocol’s economics.

Comparing Rabby’s simulation to other wallet approaches

Most wallets, including MetaMask, show users a gas estimate and a transaction summary but rely on the DEX interface to provide the slippage estimate. The user sees “Send 100 USDC, receive approximately 0.055 ETH” without independent verification of what “approximately” means under current market conditions. Some wallets offer integration with MEV protection services, but that protection is optional and requires the user to understand and enable it explicitly.

Rabby’s approach differs because the simulation is built into the core transaction preview and occurs automatically for every transaction. Users do not need to manually enable price checking or select a specific protection service; the pre-sign calculation is the default. When you download the rabby wallet extension download, the transaction simulation and balance preview features are active from the first swap, no configuration required.

That said, Rabby’s simulation is still subject to the mempool and MEV. The simulation shows the outcome if the transaction executes next, but if the transaction sits in the mempool for several blocks or if a MEV bot front-runs it, the actual outcome may differ. Rabby does not route transactions through MEV-resistant services like MEV-Blocker or Flashbots Protect by default; those are optional integrations. The simulation therefore provides clarity about price impact under normal conditions but does not eliminate the risk of intentional manipulation by miners or validators.

For traders who frequently execute large swaps or who prioritize speed over protection, Rabby’s approach offers a meaningful improvement over wallets that provide no pre-sign visibility. For institutional traders or those moving very large positions, additional protections such as private mempools, batch auctions, or threshold encryption may be necessary. Rabby’s strength is making the ordinary case—a retail trader swapping on Uniswap or another major DEX—safer by showing exactly what will happen before committing.

Practical workflow for a swap-heavy trader using Rabby’s previews

A trader planning to swap 10 ETH for USDC opens Uniswap in a browser alongside Rabby Wallet. They enter the trade parameters—10 ETH input, no specific output, maximum 1% slippage. Uniswap’s interface calculates a quoted output, showing something like “You will receive approximately 19,500 USDC.” The trader then clicks the swap button. At this point, Rabby intercepts the transaction, simulates it against the current blockchain state, and displays a preview.

The preview shows “Send 10 ETH, Receive 19,420 USDC” along with the slippage percentage, the fee paid to the DEX, and any gas costs. If the preview shows 0.4% slippage, that is well within the 1% tolerance and the trader can sign confidently. If the preview shows 1.8% slippage—suggesting that the pool has moved or that the quoted rate was stale—the trader can cancel, wait, and retry. The key is that the decision to proceed is based on a current, accurate simulation rather than a quote that may be seconds or minutes old.

For a trader executing multiple swaps per day, this workflow becomes routine. Rabby’s preview becomes a checkpoint: does this outcome match what I expected? If not, why not? The answer is always visible in the balance change and the slippage percentage. Over time, this visibility helps traders refine their risk tolerance, understand the relationship between trade size and slippage, and avoid signing transactions that will produce unexpectedly poor outcomes.

For protection against MEV, a disciplined trader might use Rabby’s preview to set a tight slippage tolerance, breaking large trades into smaller orders to reduce price impact. Some traders pair Rabby with MEV protection by routing through MEV-Blocker or by timing trades during lower-congestion periods. The point is that Rabby provides the visibility to make these decisions; it does not dictate which protection strategy is appropriate for each trader’s risk profile and transaction size.

Why transaction simulation matters for on-chain risk awareness

The deeper value of pre-sign simulation is behavioral. When users see the actual output of their transaction before signing, they develop a more accurate mental model of how DEXs work. They understand that slippage is not a percentage chosen arbitrarily but a reflection of the liquidity depth and their position size. They recognize that large trades incur larger slippage and that timing matters. They see directly that a 0.1% slippage tolerance on a large swap will often result in a failed transaction, whereas 1% may be necessary.

This awareness also extends to recognizing when something is wrong. A trader accustomed to seeing 0.5% slippage on a routine swap will notice immediately if a preview shows 5% slippage without obvious reason. That mismatch is a signal to investigate: has the pool been attacked, is a MEV bot active, or is the asset pair experiencing unusual volatility? Rather than blindly trusting the DEX interface or the wallet’s gas estimate, the trader can observe the raw data—the input, output, and slippage—and make an informed decision.

For the Ethereum ecosystem and EVM-compatible chains, this level of transparency has become increasingly important as MEV and flash loan exploits have grown more sophisticated. Rabby’s focus on transaction interpretation and balance preview directly addresses that shift. The wallet is most valuable not for users executing occasional small trades but for those who use DeFi regularly, who move meaningful amounts, and who benefit from visibility into what their transactions will actually do before they commit to signing.