Rabby Wallet: Understanding Slippage Simulation—How Pre-Sign Alerts Prevent Flash Loan Sandwich Attacks

A user initiates a swap on Uniswap or another decentralized exchange. The transaction is broadcast but not yet confirmed. Within seconds, a searcher detects it in the mempool, places a competing transaction ahead of it with a higher gas price, executes a large trade that moves the price unfavorably, and then allows the user’s swap to settle at a worse rate. The user signs, the transaction confirms, and the loss is locked in. This pattern—a sandwich attack—is one of the most common and profitable forms of miner extractable value (MEV) exploitation on Ethereum and EVM-compatible networks. The risk is not theoretical. Users lose millions annually to slippage worse than expected and price movements they could not see coming. Rabby wallet addresses this through transaction simulation and pre-sign alerts, a mechanism that reveals the complete transaction outcome before the user commits funds.

Understanding how Rabby wallet’s security checking works requires examining the gap between what a user sees in the interface and what actually happens on-chain. A simple swap might display “you send 1 ETH, you receive 18.5 USDC,” but that number reflects only the current mempool state and market price. It does not account for the execution path, network congestion, or malicious ordering by validators. A pre-sign alert system that simulates the transaction can estimate the actual outcome, flag unusual price impacts, and warn the user if the final amount differs significantly from the quoted amount. This simulation happens before any transaction is signed or broadcast, giving the user a chance to cancel rather than discover the loss after confirmation.

How MEV sandwich attacks work on Ethereum and EVM chains

A sandwich attack requires three components: visibility, ordering, and profit extraction. Ethereum’s public mempool allows anyone to monitor pending transactions. A searcher can see that a user is swapping 100 USDC for USDT, can calculate that this trade will move the USDT-USDC price, and can construct a profitable trade sequence. The searcher sends a transaction that will be included before the user’s swap (the “front-run”), causing the price to move in their favor. The user’s transaction executes at a worse price than expected. The searcher sends a transaction after the user’s swap (the “back-run”), reversing the position and capturing the spread. The entire sequence is atomic: if the profit margins disappear, the searcher can withdraw the transactions and pay only for the failed attempt.

The impact on the user is slippage beyond what decentralized exchange interfaces typically account for. A user might request a 0.5% slippage tolerance, meaning the protocol will reject the swap if the received amount falls more than 0.5% below the quoted minimum. But the quote itself can be out of date by the time the transaction is included. If a sandwich attack precedes the user’s swap, the actual price is substantially worse than the quote, and the user’s transaction still executes because the slippage tolerance is measured against a stale quote rather than the fair market price.

The root cause is information asymmetry combined with transaction ordering. Validators and searchers have superior view of the transaction order and can prioritize their own transactions. The user has only the interface display and the hope that the swap will execute close to the quoted price. On high-volume days when gas prices spike, sandwich attacks become more profitable and therefore more frequent. The user bears the cost entirely; the slippage is simply subtracted from the final amount received.

Defending against sandwich attacks has led to several strategies: private mempools such as MEV-Blocker or Flashbots Protect, intent-based architectures that abstract transaction ordering, batch auctions that execute multiple swaps in a single block with no ordering bias, and protocol-level changes such as encrypted transactions and threshold encryption. Rabby wallet cannot control block building or validator ordering, but it can reveal the problem before the user signs.

Understanding transaction simulation and pre-sign checking

Transaction simulation is the process of executing a transaction against the current blockchain state without actually broadcasting it. A simulation engine takes the transaction data—the contract being called, the function, the input parameters—and runs it through the Ethereum Virtual Machine (EVM) in a read-only environment. The result is a detailed view of what will happen: how many tokens will be transferred, what state changes will occur, and whether the transaction will succeed or revert. Rabby wallet integrates this capability to give users a preview before they sign.

Pre-sign alerts are the practical application. When a user prepares a transaction in Rabby wallet—whether a swap, a token approval, or a contract interaction—the wallet automatically simulates it. If the simulation reveals that the transaction will fail, that an approval is being granted to a suspicious address, or that the final amount differs significantly from the displayed expectation, Rabby displays a warning. The user sees the risk before committing, not after. This is different from post-signature monitoring, which can only flag problems after the transaction is already signed and potentially broadcast.

For a swap transaction, the simulation reveals the exact number of tokens that will be returned given the current contract state and mempool conditions. If the user’s Rabby wallet extension displays “you will receive 18.5 USDC,” the simulation has verified that swapping at that moment against that liquidity pool will indeed return approximately 18.5 USDC. If a sandwich attack has already shifted the price, the simulation will show a lower amount, and the pre-sign alert will flag the discrepancy. The user can then compare the simulated amount against their acceptable slippage threshold and decide whether to proceed, adjust the swap size, or cancel.

The security checking layer adds another dimension. Rabby’s pre-sign system can identify transactions that send funds to unexpected addresses, approve spenders for entire token balances, interact with newly deployed contracts, or exhibit other suspicious patterns. Not all warnings are equally severe. An approval to a trusted DEI router is routine; an approval to an unknown address that immediately sends all tokens elsewhere is a red flag. Rabby distinguishes between these cases by checking the contract address against known reputable protocols, examining approval amounts, and flagging interactions with contracts created recently or without public verification.

How balance change previews expose slippage discrepancies

One of Rabby wallet’s more practical features is the balance change preview. Before the user signs, Rabby displays not just the transaction details but the net change in the user’s token balances if the transaction executes. For a swap, this means showing both the outgoing and incoming token amounts in the same view. For a liquidity addition, it shows how many tokens will be added to the pool and what portion of the pool the user will receive. For a contract interaction that bundles several transfers, it shows the complete result.

The value of this preview is that it makes slippage visible. A user might approve a swap that quotes “send 1 ETH, receive 18 USDC,” but the preview might show “your balance will change by -1.0 ETH and +17.1 USDC.” The discrepancy between 18 USDC quoted and 17.1 USDC previewed reveals slippage and gives the user an opportunity to investigate. Is the slippage reasonable given current market conditions? Has a sandwich attack already begun? Should the user wait for lower gas prices and a less congested mempool? Or should they simply adjust their slippage tolerance and try again?

The balance change preview also prevents another category of error: incorrect contract interaction. A user intending to stake tokens might accidentally interact with a contract that sells them at a market order instead. The preview would show the unintended balance change immediately. Similarly, a liquidity provider might intend to add equal amounts of two tokens but prepare a transaction that adds a heavily skewed ratio due to a copy-paste error. The preview makes this visible before signing rather than discovering it after the transaction has been included in a block.

This mechanism is distinct from simple transaction previews shown by less careful wallet software. Rabby’s preview is backed by actual simulation. It reflects the state of the blockchain at the moment of preview generation, the liquidity in the pools being used, the current gas price environment, and the effects of any pending transactions. If the mempool changes significantly between the preview and the broadcast, the actual outcome may differ. But the preview gives the user a realistic baseline rather than an aspirational quote that ignores network conditions.

Comparing Rabby wallet’s approach to other protection mechanisms

Other wallets and DEX interfaces offer slippage settings and warnings, but few go as far as Rabby wallet’s pre-sign alerts. MetaMask, the most widely used Ethereum wallet, does not natively simulate transactions or provide balance change previews. Users must rely on the interface shown by the dapp they are interacting with, and MetaMask simply displays the transaction details before prompting for signature. If the dapp’s quote is stale or if a sandwich attack has already begun, MetaMask does not warn the user.

Decentralized exchange interfaces themselves often show slippage tolerance settings, allowing users to choose a maximum percentage loss they will accept. But this is reactive rather than proactive. The tolerance is only checked after the transaction is included and confirmed, at which point the slippage is locked in. A tolerance of 0.5% might be appropriate in normal market conditions but too high during a sandwich attack, and the dapp interface cannot know this in advance without simulation.

Some advanced users employ MEV-resistant routing options such as MEV-Blocker, which broadcasts transactions to private relays instead of the public mempool. This approach can reduce sandwich attacks at the source, but it requires understanding the trade-off: private relays may have less liquidity available or may delay confirmation slightly. Rabby wallet’s simulation approach is complementary. It works with any routing choice and alerts users to problems without forcing them to adopt a specific relay or bundler.

Hardware wallet integration in Rabby wallet also strengthens the security model. By supporting hardware wallets and watch-only wallet functionality alongside standard private key management, Rabby allows users to choose custody and signing arrangements. A user can import their hardware wallet, use Rabby for simulation and monitoring, and maintain their private keys offline. The pre-sign checking happens before the transaction reaches the hardware device, allowing the user to review the simulated outcome on a trusted interface before deciding whether to authorize the signature.

Practical limits of pre-sign simulation and when attacks still succeed

Transaction simulation is powerful, but it is not a complete shield against all MEV or slippage. The simulation is a point-in-time snapshot. It reflects the blockchain state and mempool state at the moment the user clicks “preview” or “sign.” Between the preview and the actual broadcast and inclusion, conditions can change. If the user previews a swap, sees a reasonable quoted amount, waits five minutes while considering, and then signs, the preview may no longer be accurate. New trades may have shifted the pool balance; the gas price may have changed, affecting the priority of the transaction; or an attacker may have positioned a sandwich already.

The second limitation is visibility. Rabby wallet can see pending transactions in the public mempool, but it cannot see transactions in private pools or bundles constructed by validators and sequencers before a block is built. On protocols with private relay support, the mempool may be hidden entirely from wallet software. A transaction built inside a block rather than broadcast to the public mempool will appear only after it is already confirmed, at which point the user cannot cancel it.

The third limitation is simulation accuracy. A transaction simulation must make assumptions about the order in which transactions in the current mempool will be included. If the actual order differs—perhaps because a validator prioritizes high-fee transactions differently, or because a bundle reorders transactions—then the simulated outcome will differ from the actual outcome. Complex transactions involving multiple contract calls, conditional logic, or external calls to oracle services are harder to simulate accurately.

For these reasons, Rabby wallet’s pre-sign alerts should be understood as a risk reduction tool, not a guarantee. They are most effective at catching obvious errors and severe slippage scenarios. They improve the user’s ability to make an informed decision before signing. But they cannot eliminate MEV or guarantee that the transaction will execute at the simulated price. Users should treat the preview as a reality check: if the preview shows slippage much worse than expected, they should investigate or cancel. If the preview shows reasonable results, the transaction is still subject to ordering risk and mempool changes, but the user has at least confirmed that the basic parameters are sensible.

Setting up Rabby wallet and understanding security checking features

Users can download Rabby wallet from the official rabby.io domain, where the browser extension, mobile apps for Android and iOS, and desktop applications are available. Installation is straightforward: for the browser extension, users add Rabby to their preferred Chromium browser (Chrome, Brave, Edge, etc.), create or import a wallet, and Rabby becomes available in the toolbar. The setup process prompts the user to secure their recovery phrase—a critical step that should be done carefully and offline.

Once installed, Rabby wallet automatically monitors all transactions initiated through it. When a user prepares to sign a transaction, Rabby simulates it and displays any pre-sign alerts. The alerts are categorized by severity: critical warnings block transaction signing entirely, such as if the transaction would send all tokens to a known malicious contract. High-severity warnings flag suspicious approvals or large unexpected transfers but allow the user to proceed. Low-severity warnings are informational, such as when a contract is very newly deployed or when an approval exceeds the swap amount.

For users concerned about recovery phrase security, Rabby emphasizes the importance of storing recovery phrases offline and not entering them into any website or untrusted software. The wallet supports hardware wallet integration, allowing users to keep private keys entirely off the internet-connected device. For those importing an existing MetaMask wallet or other EVM wallet, Rabby provides straightforward import options while maintaining the same security principles: the user retains control of private keys, and Rabby does not custody any funds.

Watch-only wallet functionality is another security feature. Users can add a wallet address to Rabby as watch-only, allowing them to monitor balance and transaction history without storing the private key. This is useful for observing a hardware wallet address, a cold storage address, or a multisig wallet without risking key exposure. The watch-only wallet can receive transaction simulations and alerts, but it cannot sign transactions.

Designing transaction flows that survive MEV pressure

Users armed with Rabby wallet’s pre-sign alerts can make better decisions about transaction timing and structure. The first decision is timing: broadcast during high congestion means higher gas prices and greater incentive for sandwich attacks. Broadcasting during lower-congestion periods can reduce both. Rabby wallet’s simulation will show higher or lower gas estimates depending on current conditions, helping users choose when to proceed.

The second decision is swap size. Large swaps have larger price impact and create larger profit opportunities for sandwich attackers. Breaking a large swap into multiple smaller swaps can reduce the per-transaction slippage, though it increases total gas costs. Rabby wallet’s balance change preview helps users assess whether the slippage on a single large swap is acceptable or whether splitting is worthwhile.

The third decision is routing. Some DEX aggregators attempt to minimize slippage by splitting orders across multiple pools or chains. Others prioritize simplicity. When you download Rabby wallet extension and prepare a swap, you may see options for different routes or relays. Testing a route through simulation before signing allows comparison of outcomes. A route that provides better quotes but passes through a less-reputable intermediary can be evaluated against the actual financial trade-off.

The fourth decision is slippage tolerance itself. This setting in DEX interfaces controls the maximum loss the transaction will accept. A user seeing through Rabby wallet’s preview that slippage is already 2% might set tolerance to 3% to give the transaction a chance to execute. Conversely, if preview shows only 0.1% slippage in normal conditions but the user sets tolerance to 5%, they are accepting unnecessary risk if a sandwich attack or network congestion occurs between preview and confirmation.

The future of wallet-level MEV defense and pre-sign simulation

Transaction simulation and pre-sign alerts are growing more sophisticated as wallets compete on security features. Rabby wallet’s implementation is representative of a trend: rather than requiring users to understand MEV or complex protocol interactions, wallets automate detection and present warnings in accessible terms. Future developments may include more granular control over transaction ordering, integration with private relays by default, simulation accuracy improvements as EVMs become more complex, and cross-chain simulation as users increasingly interact with multiple networks.

The broader context is a shift in where security decisions happen. Traditionally, a centralized exchange handled ordering and custody, making security the exchange’s responsibility and the user’s liability when something went wrong. In decentralized finance, the user controls the transaction but lacks visibility into its fate. Wallet software like rabby wallet extension / rabby wallet download / rabby wallet aims to bridge this gap by providing transparency and warnings at the moment of decision rather than waiting until the transaction has been confirmed.

As MEV research continues, new attack patterns and new defenses will emerge. MEV-resistant sequencing, encrypted mempools, and intent-based architectures aim to solve the problem at the protocol level. Until those changes are mainstream, users need tools that reveal risk at the application level. Pre-sign simulation and balance change previews are not perfect, but they represent a significant improvement over signing transactions blind and discovering losses after confirmation. A user who understands how these tools work and uses them consistently will avoid a substantial fraction of avoidable slippage and MEV exploitation.