Ethereum
Aave Oracle Glitch Triggers $26M in Wrongful Liquidations
A sudden pricing glitch inside the Aave lending protocol triggered roughly $26 million in unexpected liquidations, wiping out collateral across dozens of user positions within minutes. The incident sent shockwaves through the DeFi community and quickly raised questions about oracle reliability, automated liquidation systems, and the risks of fully automated financial infrastructure.
The event did not stem from a market crash or manipulation. Instead, it originated from a technical misconfiguration in Aave’s internal risk oracle, which temporarily reported the wrong exchange rate for wrapped staked Ether, known as wstETH. As a result, healthy positions were mistakenly flagged as undercollateralized and automatically liquidated by on-chain bots.
Aave governance and risk teams have acknowledged the issue and confirmed that affected users will be compensated.
What Happened
The incident affected users who had borrowed assets using wstETH as collateral on Aave v3. In normal conditions, these positions were well within safe collateralization levels.
However, the system suddenly began reporting an incorrect value for wstETH.
The faulty data caused Aave’s risk engine to believe the collateral backing certain loans had dropped below required thresholds. Once that threshold is breached, the protocol automatically allows liquidation bots to repay a borrower’s debt and seize part of the collateral as a reward.
Because the protocol operates autonomously, liquidations were triggered immediately.
Within a short window:
- 34 user accounts were liquidated
- About 10,900 wstETH worth roughly $26 million was forcibly liquidated
- Liquidation bots earned approximately 499 ETH in liquidation bonuses
For affected users, the liquidations appeared to come out of nowhere. Many positions had healthy collateral ratios moments before the glitch occurred.
The Root Cause: CAPO Oracle Misconfiguration
Early speculation suggested that an external price oracle had malfunctioned. But the root cause turned out to be more subtle.
The problem originated inside Aave’s own internal pricing mechanism, known as the Collateral Asset Price Oracle (CAPO).
CAPO is designed as a safety mechanism that limits how quickly asset prices can change inside the protocol. Its purpose is to prevent oracle manipulation or sudden price spikes from destabilizing the system.
Ironically, this protective system is exactly what caused the failure.
A mismatch occurred between two parameters used by CAPO:
- the snapshot ratio
- the timestamp used to calculate the reference exchange rate
Because of an update process mismatch between off-chain calculations and on-chain limits, the system could not correctly update the exchange rate.
The oracle therefore reported a capped exchange rate of around 1.1939, while the real market rate was closer to 1.228.
This created an artificial 2.85% price discount for wstETH inside the protocol.
That small difference was enough to push many leveraged positions below the liquidation threshold.
How the Liquidations Unfolded
DeFi liquidation systems operate with zero human oversight.
Bots constantly scan the blockchain for positions whose health factor drops below 1, meaning the collateral no longer sufficiently covers the borrowed assets.
Once CAPO reported the discounted price, the system automatically flagged numerous accounts as unsafe.
Liquidation bots immediately executed the opportunity.
Within seconds:
- Bots repaid part of the borrowers’ debt.
- The protocol transferred their collateral.
- Bots collected liquidation bonuses.
This chain reaction created a rapid wave of liquidations across the affected positions.
Importantly, the market price of wstETH never actually crashed. The liquidations occurred purely due to the incorrect oracle value.
How Much Was Lost
Blockchain analysts tracking the incident estimate the total value of liquidated collateral at roughly $26 million.
The liquidations impacted 34 different wallets, most of them using Aave’s E-Mode, a configuration designed to allow higher leverage when using correlated assets like ETH derivatives.
Approximately 10,938 wstETH was liquidated during the event.
The liquidation bots that executed the transactions collected around 499 ETH in rewards, which is typical for DeFi liquidations where bots compete to seize profitable opportunities.
Despite the event, the protocol itself did not incur bad debt, meaning Aave remained solvent throughout the incident.
Compensation Plan for Affected Users
Shortly after the event, Aave governance contributors and risk management firm Chaos Labs confirmed that users will be reimbursed for the losses caused by the glitch.
The reimbursement plan involves several steps.
First, part of the liquidation rewards was recovered through refunds from infrastructure providers. Approximately 141 ETH has already been recovered.
The remaining compensation is expected to come from the Aave DAO treasury, with roughly 345 ETH allocated to cover outstanding losses.
This approach ensures that borrowers affected by the glitch will receive the equivalent value of their liquidated positions.
While compensation cannot undo the disruption or stress caused by the event, the swift response from the protocol has been viewed as a positive sign by many in the DeFi community.
Why Oracle Reliability Matters in DeFi
The incident highlights one of the fundamental risks in decentralized finance: data integrity.
Smart contracts are deterministic. They execute instructions exactly as written, with no human judgment or intervention.
If the input data is wrong, the system will still execute.
Price oracles act as the bridge between blockchain applications and external market data. They are therefore one of the most critical components of DeFi infrastructure.
When oracle data becomes inaccurate, the consequences can cascade quickly across lending markets.
Even small deviations can trigger large-scale liquidations.
In this case, a 2.85% pricing error was enough to wipe out tens of millions of dollars in collateral.
Not an Oracle Hack
Importantly, this event was not caused by a hack or price manipulation attack.
The main price feeds used by Aave continued to function correctly.
Instead, the issue was a configuration error in the protocol’s internal safety logic, which processed the correct price data incorrectly.
This distinction matters.
A hack implies an external attacker exploiting a vulnerability. In this case, the system simply followed its programmed logic based on faulty internal parameters.
In other words, the code worked exactly as written — but the configuration was wrong.
What Comes Next for Aave
The incident has already sparked discussions within the Aave governance community about improving safeguards around oracle infrastructure.
Several potential improvements are now being considered, including:
- additional validation layers for oracle updates
- circuit breakers that pause liquidations during abnormal price deviations
- stricter testing procedures for parameter changes
These mechanisms could help prevent similar incidents from triggering automated liquidations in the future.
As DeFi protocols continue to scale, events like this demonstrate how small technical mismatches can lead to multi-million-dollar consequences.
A Reminder of DeFi’s Structural Risks
Despite years of growth and billions in total value locked, decentralized finance remains a software-driven financial system.
That means its risks are not limited to market volatility.
They also include:
- smart contract logic
- configuration errors
- oracle infrastructure
- governance decisions
The Aave liquidation event illustrates how these risks can surface even in one of the most established DeFi lending protocols.
For users, the takeaway is simple: automation removes intermediaries, but it does not remove risk.
And sometimes, all it takes is a 2.85% pricing glitch to trigger a $26 million cascade.