Yearn Finance yETH Contract Flaw Exposed: Millions Drained in Exploit
A smart contract vulnerability in Yearn Finance's yETH vault has been exploited, draining millions from the protocol.
### The Attack Vector
The exploit didn't require a sophisticated zero-day—it leveraged a known weakness in the contract's rebalancing logic. The attacker manipulated price feeds and contract interactions to drain funds systematically, bypassing standard security checks that should have flagged the anomalous transactions.
### The Aftermath
Funds moved through a series of decentralized exchanges before being bridged to other chains. The incident triggered automatic pauses in related contracts, but the damage was done. It's another stark reminder that in DeFi, the fine print isn't just legalese—it's code, and sometimes that code has a price.
### The Bigger Picture
This isn't just about one vault or one protocol. It highlights the persistent tension between innovation and security in a sector that moves at breakneck speed. While teams race to build the next yield-generating machine, attackers are patiently probing for the single loose bolt—proving once again that in crypto finance, the most reliable yield sometimes comes from other people's mistakes.
Read us on Google News
In brief
- Yearn Finance loses 9 million due to a flaw in a custom swap contract.
- The technical bug: a division omitted in the calculation of the virtual balance product.
- The attacker uses temporary contracts to drain assets and obfuscate the trail.
- A single transaction is enough to pocket 100% of the affected yETH pool liquidity.
When arithmetic explodes: a bug worth millions
On November 30, a user was able to create 2.35 × 10³⁸ yETH thanks to a subtle flaw in the swap() function of the smart contract. This contract was supposed to maintain a balance rule between tokens. Except a critical division was omitted in the formula. Result: the variable vb_prod ran away. Like a speedometer stuck in overdrive, it deceived the protocol about its own health.
The exploit was confirmed by PeckShield, who alerted in a tweet that nearly 9 million dollars had been lost. Part of the funds — about 3 million in ETH — was sent via Tornado Cash, a famous crypto mixer used to obscure trails. The rest still sleeps in the hacker’s address.
The severity of the bug is not a simple oversight. As Ilia.eth explained on X:
Today’s exploitation of the $yETH pool was not a flash loan type price attack, but indeed a structural collapse of the AMM’s internal accounting. Here is a technical analysis showing how a simple omitted division led to complete protocol drainage.
This flaw painfully recalls the precedent of Balancer, where poor rounding management caused similar chaos. Same cause, same effect: uncontrolled monetary creation followed by a legitimate but destructive withdrawal.
Helper contracts to raze Yearn Finance’s architecture
It’s not just the bug that impresses. It’s the attack engineering. In a single transaction, the hacker orchestrated everything: deployment of “helper contracts,” token minting, conversion to ETH, fund transfer, and self-destruction of contracts to erase traces.
According to Blockscout, each helper contract executed a targeted call to the vulnerable function, then sent the ETH to a master wallet before disappearing. A strategy worthy of a heist movie, where the robber erases his digital footprints in the same second he acts.
The key address identified by several analysts is: 0xa80d…c822, currently still holding about 6 million in stETH, rETH, and other ethereum derivatives.
On X, William Li offers further reading:
The hacker actually did not withdraw all the yETH he created, he only sold part of it in the yETH-ETH pool for 1,000 ETH (about 3 million dollars) — which is far less than the real gain he made (P2).
More than a theft, it is therefore a controlled disintegration of the yETH protocol. And behind the attack, a DEEP mathematical knowledge, coupled with cold and precise programming talent.
Crypto and trust: when code becomes Achilles’ heel
Yearn Finance is far from an amateur project. Yet, the flaw was detected neither by users nor by audits. This is where the matter becomes worrying for the entire crypto market. Because this type of error — a multiplication instead of a division — could exist elsewhere, lurking in other protocols.
The yETH contract structure is a hybrid between Curve and Balancer. Except that instead of recalculating each transaction, it stores an intermediate state (vb_prod) supposed to be updated after each swap. A dangerous practice, according to Ilia.eth:
Storing complex product results (vb_prod) to update them incrementally is extremely risky. Errors accumulate, and the slightest logical bug can remain active indefinitely. It WOULD be better to recalculate invariants from current balances.
The hack revives the debate: should gas economy or rigor be prioritized? One thing is certain: the consequences of a botched trade-off now amount to millions. At Yearn, the time is for remobilization: SEAL911, ChainSecurity, and a post-mortem investigation are already on the front line.
5 key facts about the Yearn Finance exploit
- November 30, 2025: date of the hack;
- $9 million: estimated total losses;
- 2.35 × 10³⁸ yETH: artificially created tokens;
- Single transaction: the entire attack happened in one block;
- Helper contracts: deployed, used, then self-destructed.
Calculation errors in crypto do not forgive. And for good reason: it’s not another audit that would have avoided the carnage. Balancer, despite 11 security audits, was also emptied by an almost twin bug. A simple multiplication factor can become a weapon of mass destruction when finance becomes programmable. Protocols have short memory, but blockchains never forget.
Maximize your Cointribune experience with our "Read to Earn" program! For every article you read, earn points and access exclusive rewards. Sign up now and start earning benefits.
