A liquidator using Composable Finance’s isoUSD protocol has a technical problem that affects how transaction safety works in decentralized finance. The liquidator wants to execute a multi-step flash loan sequence: borrow funds, manipulate a price oracle, trigger a liquidation, and repay the loan—all in a single atomic transaction. Before signing, they expect their wallet to warn them about execution risk. Rabby, which is installed as a browser extension on millions of Ethereum and EVM users’ devices, offers transaction simulation with risk alerts as a core safety feature. But when that liquidator inspects the transaction in Rabby, the simulation shows only the outermost call, not the internal flash loan mechanics, the oracle interaction, or the cascading dependency that makes execution conditional on factors outside the liquidator’s control.
That gap between what a wallet shows and what actually executes on-chain reveals a structural blindspot in how transaction simulation works at scale. A risk alert system that operates sequentially—checking each transaction step as it appears in the mempool or signing interface—cannot reconstruct a flash loan’s internal state changes or detect whether downstream operations will succeed. The liquidator may believe they understand the risk. The wallet shows what looks like a straightforward liquidation call. But the simulation is incomplete. When Composable’s oracle responds to the flash loan’s temporary price movement, or when the collateral liquidation fails due to slippage or updated market conditions during the same block, the user discovers that the warning system was not designed to model these multi-step dependencies.

How transaction simulation works in Rabby wallet extension
Transaction simulation is a deliberate attempt to predict whether a transaction will succeed or fail before the user signs it. Rabby implements this through static analysis and call-level simulation, providing a preview of outcomes before on-chain execution. The system checks for common patterns: whether an address is flagged as malicious, whether token approvals are unusually large, whether a swap quote has degraded, or whether a contract interaction would transfer unexpected assets. These checks operate within the scope of a single transaction’s top-level call.
The critical constraint is that Rabby’s simulation cannot execute arbitrary contract code in a complete EVM sandbox during the signing flow. Doing so would require running a full Ethereum node or equivalent validator logic on every browser, which is computationally prohibitive. Instead, the wallet uses heuristics: it decodes function signatures, checks known malicious patterns, queries external APIs for contract metadata, and tracks historical behavior of interactions with certain protocols. This approach scales and provides genuine value for routine transactions.
For a simple swap—User sends Token A to an exchange, receives Token B—simulation can identify whether the minimum output has dropped below an acceptable threshold or whether the contract address has recently changed. For a basic collateral liquidation on Aave or Compound, the system can flag whether an account is actually liquidatable or whether the transaction would revert due to insufficient borrowing. These warnings work because the transaction’s outcome depends primarily on external state that can be queried: current prices, account balances, borrowing levels, and protocol parameters.
Composable Finance’s isoUSD protocol and similar architectures introduce a new layer. When a liquidator initiates a flash loan within a single transaction, that transaction contains internal state changes that affect downstream operations. The flash loan temporarily increases the liquidator’s balance. Then, the liquidator may trigger an oracle update, perform a swap, or manipulate a price feed using the borrowed funds. Then comes the liquidation itself. Finally, the loan must be repaid. If any step fails—the swap slips too far, the oracle update reverts, the liquidation doesn’t produce enough collateral—the entire transaction reverts and the borrowed funds return to their original location as if the loan never occurred.
Rabby’s transaction simulation layer sees only the entry point. The rabby wallet extension will show that a flashLoan call is being made and that certain assets are being transferred as inputs. It may flag whether the liquidation contract has a known exploit history or whether the token approvals are suspicious. But the wallet cannot trace whether the internal call to update an oracle will succeed given the temporary price movement introduced by the flash loan, or whether the liquidation will produce the expected collateral output once the oracle sees the manipulated price. That conditional dependency is internal to the flash loan sequence and invisible to the per-transaction simulation model.
The blindspot: Multi-step atomic execution and internal state
Flash loans are powerful precisely because they atomically combine multiple operations that would otherwise require separate transactions and inter-transaction security assumptions. A liquidator no longer needs to own capital upfront; they borrow, execute, and repay in one block. But that atomicity also creates an asymmetry between what the wallet can simulate and what the protocol actually executes.
Consider a concrete sequence. A liquidator discovers that User X has overextended their position in Composable’s isoUSD: they have borrowed isoUSD against ETH collateral, and the ETH price has declined. The liquidator could simply call the liquidation function directly, but Composable’s liquidation may require the liquidator to provide isoUSD liquidity or to have already deposited collateral themselves. Instead, the liquidator constructs a flash loan sequence: borrow isoUSD from a lending pool, use that isoUSD to trigger the liquidation function (which transfers User X’s ETH collateral to the liquidator), swap the ETH for stablecoin to repay the isoUSD flash loan with profit.
The transaction submitted to the mempool is a single contract call to a liquidator contract that executes all three steps. Rabby’s simulation engine decodes the transaction and sees: “Calling liquidator contract at 0x[address]. Will interact with Composable protocol. May transfer ERC-20 tokens.” The simulation may query the liquidator contract’s history, check whether it has been flagged as malicious, and verify that the transaction is cryptographically valid. But the simulation cannot predict whether the oracle that prices User X’s collateral will respond as expected when the flash loan temporarily inflates isoUSD supply, whether the collateral transfer will execute given the updated price, or whether the ETH-to-stablecoin swap will produce enough output to repay the loan.
Each of those sub-operations has a failure mode. If the oracle uses a time-weighted average price (TWAP), it may not respond instantly to the flash loan. If the liquidation function checks collateral ratios using a different oracle than the one the liquidator assumed, the execution path diverges. If slippage during the ETH swap exceeds the allowed threshold, the swap reverts, and the entire transaction rolls back—including the flash loan repayment, which means the transaction fails and the user’s gas is consumed.
Risk alerts and the limits of per-transaction scope
A responsible wallet shows warnings when risk is detectable within the transaction’s declared scope. Rabby implements several categories. Token approval warnings alert the user if an allowance is unusually large or open-ended. Malicious contract warnings appear if an address matches a known phishing list or known exploit contract. Slippage warnings flag when a swap’s minimum output is set to zero or when the difference between expected and minimum output exceeds a threshold. Value-at-risk warnings appear when a large transfer or collateral change is detected.
These warnings are most effective when the transaction’s outcome depends on factors external to the wallet’s simulation. An approval that is too large remains risky whether the user signs immediately or tomorrow. A known malicious contract remains dangerous regardless of when the transaction executes. But flash loan sequences depend on internal conditions that change during the transaction itself.
When Rabby displays a risk alert for a Composable isoUSD liquidation, the alert is anchored to what the simulation can detect: the collateral transfer, the protocol interaction, the possibility of reverts. But the liquidator reading the alert has imperfect information. They may understand that liquidations can fail, but they may not understand that the failure mode relevant to this specific sequence is not “insufficient collateral to liquidate” but rather “the oracle responded differently than expected to the internal flash loan, so the liquidation price no longer covers the borrowed isoUSD.” Rabby’s warnings are technically accurate about general risks, but they are silent about the specific risk that matters: whether the cascade of internal operations will remain solvent.
This is not a failure of Rabby’s design so much as an inherent limit of wallet-level simulation. Ethereum’s design separates wallet clients from full nodes; a wallet is not expected to run complete transaction validation. Smart contract security audits typically focus on deployed code, not on transaction sequences constructed by end users. The gap between per-transaction simulation and multi-step conditional execution is an ecosystem-level problem that no single wallet can fully solve unilaterally.
Why Composable’s isoUSD creates a particular challenge
Composable Finance’s isoUSD is a cross-chain stablecoin collateralized by multiple assets across different networks. Liquidations on Composable require the liquidator to interact with multiple oracle sources and potentially cross-chain messaging layers. The protocol allows liquidators to use flash loans, and it allows liquidations to be triggered through specific contracts that may execute additional operations before checking repayment conditions.
The technical depth creates a simulation blindspot. If a liquidator borrows isoUSD via a flash loan on Ethereum, then triggers a liquidation that relies on a price feed from Chainlink, and then swaps on Uniswap, each component has independent risk. But their combination has compounded risk because the flash loan’s effect on isoUSD supply may change how the collateral liquidation calculates the debt repayment amount. An oracle that updates slowly may quote a stale price while the liquidation executes. A swap that slips more than expected may leave the liquidator unable to repay the flash loan, causing the entire sequence to revert.
Rabby’s simulation will catch some of these risks if they manifest as low-level reverts or obviously malicious contracts. But Composable’s design allows liquidations that are complex without being malicious. A perfectly valid liquidation sequence may execute correctly in some market conditions and fail in others. The wallet’s per-transaction simulation cannot model those boundary conditions because they depend on real-time state that will change between the moment the transaction is signed and the moment it is included in a block.
The role of approval management and risk awareness
One practical defense is to use Rabby’s token approval management tools before engaging in complex liquidation sequences. The wallet allows users to review existing approvals, revoke overly broad allowances, and set spending limits on individual contracts. This does not prevent a flash loan liquidation from failing, but it does prevent an unrelated exploit from draining funds if the liquidation contract itself is compromised.
Users exploring liquidation opportunities should also review the underlying protocol documentation and run local simulations before submitting to the mempool. Tools like Tenderly or Ganache can simulate transactions with full EVM state, including all internal calls and state changes. This local simulation has no practical limit on complexity and can trace flash loan sequences step-by-step. A liquidator who runs a local simulation and sees that the oracle query will fail given the current market state can avoid submitting a transaction that will consume gas and revert.
The gap between Rabby’s browser-level simulation and full-node simulation creates a natural division of labor. The wallet’s job is to catch obvious risks and provide a user-friendly warning layer. The user’s job—when executing complex DeFi sequences—is to use deeper tools to model the specific scenario before committing to the mempool. Rabby’s risk alerts are useful as a first filter, not as a complete safety guarantee. When using Rabby wallet extension features for liquidations or other complex contract interactions, users should treat the warnings as preliminary rather than definitive.
What a more complete risk model would require
To detect flash loan liquidation blindspots, a wallet would need to either emulate the full EVM state (prohibitively expensive on a browser) or integrate with external simulation services that could reconstruct the transaction sequence, including all internal calls, and model their conditional dependencies. Some wallets have begun partnering with simulation providers. A wallet could show not just “this transaction may revert” but “this transaction will revert if the ETH price moves 2% downward before block inclusion” or “this transaction depends on oracle update X completing before liquidation step Y.”
That level of fidelity would require the wallet to decode the contract logic, understand the protocol’s structure, and model dependencies across multiple chains if applicable. It would also require updating that knowledge every time a protocol changed its liquidation mechanics or oracle integration. The practical cost is prohibitive for a free, general-purpose wallet serving 90+ EVM networks. Specialized liquidation interfaces built by the Composable team itself or by liquidation aggregators like MEV-aware relayers could provide deeper simulation for their specific use cases.
Another approach is transparency. If Composable’s liquidation contracts logged the expected oracle price, the expected liquidation amount, and the repayment requirement before executing internal calls, a user or wallet could read those values and compare them against real-time market data. Some protocols have moved in this direction, but it requires additional on-chain state management and gas costs.
Practical guidance for users and the path forward
Users engaging with flash loan liquidations or other multi-step DeFi sequences should apply a layered approach. First, use Rabby’s built-in warnings and approval management to eliminate obvious risks. Second, review the protocol documentation and understand the liquidation mechanics before constructing the sequence. Third, use local simulation tools to model the complete transaction, including all internal operations and state dependencies. Fourth, check real-time market conditions—prices, slippage, oracle data—to verify that assumptions made during local simulation are still valid. Fifth, submit the transaction to a private mempool or MEV-resistant relay rather than the public mempool, reducing the chance that market movements during block propagation will invalidate the sequence.
For the broader ecosystem, the challenge points to a need for standardized risk descriptors. Rather than each wallet independently deciding which risks to surface, protocols and simulation providers could publish machine-readable risk models: “This function succeeds only if oracle price is within 2% of spot price” or “This liquidation requires at least X liquidity in the repayment swap.” Wallets could then display these conditions to users and compare them against current state.
GitHub repositories hosting open-source wallet code increasingly include security audit reports. Rabby’s open-source nature means that liquidation sequences and wallet code can be audited together, and the community can contribute safer patterns. The transparency itself does not prevent flash loan blindspots, but it allows researchers and users to understand exactly where simulation limitations exist.
The deepest insight is that transaction safety in DeFi is not a property of individual transactions but of transaction sequences within market conditions at a specific moment in time. A wallet can warn about obvious patterns. It cannot predict whether a liquidation will succeed given future price movements, oracle updates, or block inclusion delays. Rabby wallet extension provides a useful first layer of defense, but users engaging in complex operations remain responsible for understanding the full execution path and the boundary conditions under which their sequence might fail.
Frequently asked questions
Does Rabby wallet extension simulation detect whether a flash loan liquidation will succeed?
No. Rabby’s transaction simulation operates at the top-level call scope and cannot reconstruct internal state changes or model multi-step dependencies. It can warn about obviously malicious contracts or suspicious approvals, but it cannot predict whether an internal oracle interaction or swap will produce the output required for the liquidation to succeed. Users should use local simulation tools like Tenderly before submitting flash loan sequences to the mempool.
Why do Composable isoUSD liquidations pose a particular challenge for wallet simulation?
Composable’s isoUSD liquidations often involve flash loans, oracle interactions, and cross-chain messaging within a single atomic transaction. The liquidation outcome depends on internal state changes—specifically, how the oracle responds to the temporary supply changes introduced by the flash loan. Rabby’s per-transaction simulation cannot model these internal conditional dependencies, leaving the liquidator unaware of whether the sequence will actually succeed on-chain.
What should I do before submitting a complex liquidation using Rabby wallet extension?
Review the liquidation protocol’s documentation, run a local simulation using Tenderly or Ganache to trace all internal calls, verify current market prices and oracle data, check that slippage assumptions are still valid, and consider submitting through a private mempool or MEV-resistant relay. Use Rabby’s approval management tools to limit permissions to specific contracts. Treat Rabby’s risk alerts as a preliminary layer, not as a complete safety guarantee.