Float Protocol has become the latest decentralized finance protocol to learn an old lesson the hard way: spot prices on automated market makers are not oracles. The protocol lost roughly 28,000 USD, or 10.71 ETH, after an attacker used a flash loan to manipulate a Uniswap V3 pool price and trick Float’s Hypervisor contracts into mispricing liquidity provider shares.
The attack, analyzed by blockchain security firm SlowMist, was small by 2026 standards but technically instructive. It shows how a single manipulable data point — the Uniswap V3 slot0 value, which holds a pool’s current price and tick information — can cascade through contracts that treat it as trustworthy, letting an attacker extract value deposit by deposit.
How the manipulation worked
According to SlowMist’s Aug. 31 alert, the attacker began by taking out a flash loan, a mechanism that lets traders borrow large amounts of capital without collateral as long as the loan is repaid within the same blockchain transaction. The borrowed funds were used to execute large swaps in the underlying Uniswap V3 liquidity pool, deliberately distorting the pool’s slot0 spot price.
Once the pool price had been moved, the manipulation changed the values returned by two functions the Hypervisor contracts relied on: currentTick() and getTotalAmounts(). Because the affected contracts used that manipulated data to calculate the value of liquidity provider shares, the attacker was able to repeatedly deposit and withdraw funds while the system worked with inflated share values — extracting the difference each cycle before repaying the flash loan in the same transaction.
SlowMist traced the root cause to critical functions that lacked time-weighted average price, or TWAP, verification, alternative oracle checks, and slippage protection. In plain terms, the contracts trusted a price that anyone with enough temporary capital could move.
The security firm published the relevant addresses: the attacker wallet at 0xaea29218262dc6b0904ca077f6527c49dfd426d9, the attack contract at 0xb46655eb5b77de277063a75586d1883e951b6c54, two vulnerable Hypervisor contracts, and the underlying Uniswap V3 pool used as the manipulation vector.
A familiar pattern in DeFi
Flash loan price manipulation is one of the most recurring attack patterns in decentralized finance, and 2026 has offered no shortage of examples. In July, Allbridge Core was halted after an attacker used a 1.12 million USDC flash loan from Kamini lending protocol during an exploit that PeckShield estimated caused roughly 1.65 million USD in losses. Onchain Lens reported that the attacker made rapid USDC and USDT swaps to distort a stablecoin pool ratio, then withdrew liquidity at the skewed rate before repaying the loan.
The same month, decentralized trading protocol Ostium disclosed that its 23.75 million USDC exploit originated from compromised off-chain infrastructure rather than smart contract code — a reminder that pricing weaknesses do not always live on-chain.
The Float Protocol incident fits the on-chain variant of the pattern precisely. The damage was limited to about 28,000 USD, likely because the attacker’s profit per manipulated cycle was capped by the depth of the underlying pools and the size of the flash loan the strategy could support. But the mechanism is identical to attacks that cost protocols millions, and the fix is equally well understood.
Why TWAP and oracle checks matter
Uniswap V3 pools expose both an instantaneous price (slot0) and a time-weighted average price computed from accumulated tick data. The slot0 value reflects whatever the pool’s current state happens to be — including states created seconds earlier by a large trade funded by a flash loan. TWAP values, by contrast, are far more expensive to manipulate because an attacker would need to hold the price distorted across time, tying up real capital and paying real fees and impermanent losses.
Security engineers have recommended for years that contracts that price shares, collateral, or payouts should never read slot0 directly. Best practice is to use TWAP windows, cross-reference multiple independent oracles, and enforce slippage bounds so that even a partially successful manipulation cannot extract meaningful value. The contracts involved in the Float Protocol attack skipped these layers, according to SlowMist’s analysis.
Small exploit, real signal
For liquidity providers in Float Protocol’s Hypervisor vaults, the direct damage is modest. But the incident carries a broader signal for DeFi users evaluating where to park capital. Protocol audits commonly check for oracle misuse, and functions that compute share prices from manipulable spot data are exactly the kind of finding that should surface in a competent review. The fact that these functions shipped without TWAP verification or slippage protection suggests either the code was not audited with this vector in mind, or the audit’s recommendations were not fully implemented.
Users should also note the broader environment: exploits and hacks across the industry have continued at a heavy pace, with researchers tracking billions in cumulative losses. Small incidents like this one rarely make headlines, but they are the cheapest tuition the market offers. Every protocol that prices anything against an AMM pool — vault shares, collateral ratios, reward distributions — should be checked against the same checklist SlowMist applied here.
What comes next
SlowMist’s disclosure gives the Float Protocol team a clear remediation path: replace spot price reads with TWAP-based pricing or a robust external oracle, add slippage protection to deposit and withdrawal functions, and consider rate-limiting or circuit breakers that pause vaults when share valuations move abnormally fast. Whether affected liquidity providers will be compensated from treasury funds or fees remains to be seen.
For the wider DeFi community, the 28,000 USD loss is less important than the reminder. Flash loans are not going away, and they cost an attacker almost nothing to attempt. The only real defense is contracts that refuse to trust prices a single transaction can fake.
Disclaimer: This article is for informational purposes only and does not constitute financial advice.
SlowMist traced the fake slot0 read within hours. a protocol trusting a raw pool price in 2026, the audit scope conversation matters more than the 28k
28k drained and the trick was faking slot0 with a flash loan so the oracle read a bogus price. same pattern as the last dozen defi hacks
any protocol reading spot price straight off a uni v3 pool as its oracle is asking for exactly this. solved problem and teams still ship it
exactly. TWAP has been standard for like 5 years. at some point shipping without it is negligence not a mistake
SlowMist pinned the missing TWAP check within hours of the alert. one audit should have caught this before mainnet
audits catch this only if oracle integration is in scope, and teams love carving exactly that part out to save fees
share pricing off slot0 with no twap floor, 10.71 eth payout. attacker spent more effort engineering this than they made back
10.71 ETH net for the attacker. between gas, flash loan fees and dev time on that attack contract, this barely paid for itself lol
10.71 eth is like one month of a junior solidity salary. crime that requires a full resume and pays like an internship
internship pay until you count the resale value. this exploit template gets packaged and the next team skips the audit entirely
packaged template is the scary part. every failed audit team now has a working blueprint for a 28k payday
resale value is doing heavy lifting lol, 10.71 eth for a reusable template is cheap r&d for the next crew. expect copycats until the pattern is extinct
the resale fear is overblown tbh, any auditor worth their fee greps for slot0 reads in share pricing now. the template only works on teams that never look
barely paid for itself is the wrong frame imo. the hypervisor was mispricing shares deposit by deposit, so 28k is whatever happened to be in reach that block. with more TVL sitting there this same tx prints way more
barely paid off until you price the second run. that attack contract is reusable, so the real payday is whichever hypervisor still reads slot0 for share pricing next month
flash loans letting people borrow millions uncollateralized will always feel like cheat code. 28k is small but the pattern scales
flash loans arent the problem, the uncollateralized part lasts one block and only pays if the oracle is broken. fix slot0 and the cheat code does nothing
the template resale angle is the real story. whoever buys it isnt targeting hypervisors, its every vault still quoting slot0
the flash loan is just the getaway car tho. plenty of these have been done with plain borrowed spot. slot0 as an oracle is the actual crime scene
slot0 is readable by anyone in the same block as your deposit. using it for share pricing is leaving the vault open with a closed sign on the door
closed sign on the door and the vault kept quoting every new deposit off the fake price lol. thats the part that gets me, it wasnt one bad tx it was a cascade
flash loans are collateralized by the block itself, if the tx doesnt profit it just reverts. the cheat code is float reading slot0 raw, not the loan
SlowMist had the tx diagram out same day and the root cause was still just slot0 with no twap floor. feels like a checkbox people skip to save gas
SlowMist had the alert out Aug 31 same day and the root cause was still just a raw slot0 read in the hypervisor. at some point LP share pricing needs a minimum oracle standard the way audits got checklists
28k payout and SlowMist diagrams the whole attack path for free. security firms are basically doing incident r&d for the next attacker at this point