Flash Loan Attacks in DeFi: What Happened and How to Protect Funds

A flash loan is an uncollateralized loan on a DeFi protocol. The borrower takes funds and must repay them, with any fee, before the transaction ends. If repayment does not happen, the whole transaction is reversed as if it never took place. Because the lender is protected by this rule, no collateral is needed.

Flash loans are mainly offered on Ethereum-based lending protocols. Aave V3 is one well-known example of a lending market that has offered flash loans. Developers use them for legitimate purposes such as arbitrage between exchanges, refinancing a debt position in one step, or swapping collateral without first holding the full amount.

The important point is that a flash loan gives anyone access to a large amount of capital for a few seconds, without needing to own that capital or pledge anything. That property is useful for efficient markets. It also lowers the cost of attacking a protocol that has a weakness, because an attacker can temporarily control a large sum at almost no upfront cost.

A flash loan is not an exploit on its own. The attack happens when the capital is used to trigger a flaw in the way a protocol values assets, processes calls or records balances.

Most flash loan attacks follow a similar sequence within one transaction:

1. The attacker borrows a large amount of one or more tokens through a flash loan.
2. The attacker uses those funds to move a price on a pool or exchange that another protocol relies on.
3. The attacker interacts with the target protocol while the distorted price or inconsistent state is in place. This may mean borrowing more than the collateral should allow, minting tokens at a wrong rate or withdrawing more than deposited.
4. The attacker restores the price or reverses the temporary position, then repays the flash loan with the fee.
5. The attacker keeps the difference as profit, if the attack worked.

The whole process happens inside one block. Because the steps are atomic, the attacker does not face the risk that the market moves against them between steps. That is why these attacks can look like instant, perfectly timed trades when observed on a block explorer.

Attacks often combine a flash loan with several contract calls. Analysts who study them usually break the transaction into its internal calls to see which step gave the attacker the advantage.

Research and post-mortems describe several recurring weaknesses that flash loans help exploit:

• Oracle manipulation: A protocol reads a token price from a pool that a large trade can move in the same block. If the protocol trusts that spot price, the attacker can make an asset look more or less valuable than it is.
• Reentrancy: A contract sends funds or makes an external call before updating its own records. The called contract can call back into the protocol and act on stale balances.
• Donation or balance-accounting errors: A protocol assumes its balance changes only through its own functions. A direct transfer of tokens can change its internal calculations if the contract reads its raw balance.
• Logic errors: A rule in the code does not match what the designers intended, such as a missing check on a parameter or an incorrect rounding path.

These categories overlap. A single incident can combine a price manipulation with a logic error, which makes the root cause harder to name in a summary headline.

For users, the practical lesson is that a protocol can be well known and still contain these issues. Reputation alone does not show whether a specific pool reads prices safely or handles external calls correctly.

Several incidents show the range of these attacks. In 2020, reporting on flash loan attacks against Curve Finance liquidity pools described attackers using borrowed funds to manipulate prices, and the protocol discussed changes to stop that pattern. Coverage at the time framed the combined losses from flash loan attacks across DeFi as roughly one hundred million dollars.

In May 2021, the DeFi protocol bEarn reported losses of about 11 million dollars from a flash loan attack. In April 2023, the protocol 0VIX reported losses of about 2 million dollars in a flash loan exploit, based on on-chain data at the time.

Recent analysis of larger incidents also points to case studies such as Cetus, Penpie, KyberSwap and UwU Lend, which were cited as examples of how flash loans amplify oracle, donation and reentrancy bugs into large losses.

These cases differ in scale and cause, but they share a pattern: a flash loan supplied the capital, and a flaw in price handling or contract logic supplied the opportunity. When reading about any single incident, look for the specific mechanism, the amount at risk and whether the affected funds were recovered.

A study published in the Journal of Financial Crime examined flash loan attacks from February 2020 to July 2024. Reporting on the study put total losses at about 1.2 billion dollars across 72 incidents. Coverage of the same research described the attacks as growing more sophisticated and less predictable over that period.

The same study found that logic exploits accounted for 55 percent of flash loan losses from February 2022 to July 2024, up from 28 percent in the earlier comparison window. In plain terms, a larger share of losses came from flaws in how protocol code behaved, rather than from price manipulation alone.

The shift matters for defense. Oracle protections address one class of problem, but they do not remove every logic error. Protocols need testing, review and monitoring of the full set of contract interactions, not only the price feed.

Readers should keep in mind that totals depend on how incidents are classified and valued. Some incidents involve tokens whose prices fell sharply after the attack, so dollar figures vary by method. Check the original study or a reputable summary for the exact methodology before quoting a number.

Flash loan attacks rarely harm only the protocol that was attacked. Depositors in a lending market can see their funds drained or their positions mispriced if the bad debt is not covered. Liquidity providers in an exchange pool can lose value when the pool is rebalanced at a manipulated price. Token holders can see the price of a token collapse after an exploit.

The effects also spread through connected protocols. When one protocol uses another protocol's price as its own reference, a distorted price can cause losses in both places. This is why DeFi is often described as composable, meaning protocols are linked through shared assets and calls.

For a lender, a flash loan attack can create bad debt if collateral is valued too high when a loan is opened. For an exchange, it can allow a trader to buy or sell at a price that the pool should not have offered. For a vault or yield strategy, it can cause the strategy to act on false information.

The lesson for users is to think about dependencies. A position that looks safe in one protocol may depend on price data or collateral rules set somewhere else.

Protocols use several defenses against flash loan attacks. Their effectiveness depends on how each is built and maintained:

• Manipulation-resistant price sources: Using time-weighted average prices or independent oracle networks makes it harder for one transaction to move the reference price. Pyth Network is one example of a first-party oracle provider used by blockchain applications.
• Reentrancy guards and checks-effects-interactions ordering: Updating internal balances before making external calls prevents a called contract from acting on stale data.
• Balance and accounting checks: Protocols can track internal balances instead of reading raw token balances, which reduces the risk from direct transfers.
• Collateral and borrow limits: Conservative loan-to-value settings and borrow caps limit how much damage a single distorted price can cause.
• Audits, formal verification and bug bounties: Independent review and paid bug reporting catch logic errors before attackers do.
• Pause mechanisms and monitoring: Some protocols can pause specific markets when unusual behavior appears. Governance and multisig processes determine how quickly this can happen.

No single defense covers every case. A strong protocol combines several of these measures and publishes how it handles risk. Read the protocol's documentation to see which controls it uses.

Users cannot change a protocol's code, but they can reduce their exposure with a few habits:

1. Check whether the protocol has been audited, and read the scope of each audit. An audit of one contract does not cover the whole system.
2. Look for a documented oracle setup. If the documentation does not say where prices come from, treat that as a warning sign.
3. Start with a small amount in any new or unfamiliar pool, and increase only after you understand how it works.
4. Review and revoke token approvals you no longer use. Wallet and explorer tools can list active approvals for an address.
5. Avoid pools that use a single thin market as their only price reference, especially for less liquid tokens.
6. Keep records of your positions and watch for protocol announcements about pauses, incidents or governance proposals.
7. Confirm that you are on the official site or app before connecting a wallet, since phishing pages often copy legitimate DeFi interfaces.

These steps do not remove risk. They help you avoid the most common mistakes and give you time to respond if something changes.

Flash loan attack coverage changes quickly, and the numbers and case details in news headlines can be revised. For current information, use these sources:

• The affected protocol's incident post-mortem, which usually explains the root cause, the amount lost and any recovery plan.
• Published audit reports for the protocol, including the scope and any issues that were fixed.
• On-chain transaction records on a block explorer, which show the sequence of calls in a specific attack.
• Peer-reviewed or institutional research on flash loan losses, which states its methodology and time window.
• Official protocol governance forums and announcements, where teams explain changes to risk parameters.

When comparing sources, check the date, the time window, the token prices used and whether losses were counted before or after recoveries. Two accurate reports can give different totals if they measure different things.

For readers who want to follow DeFi security more broadly, the most useful habit is to read primary sources first and treat summary headlines as a starting point.