Date: September 16, 2026, 12:37:35 UTC
Chain: HyperEVM
Loss: 425.52 WHYPE, about $33.4K
Class: permissionless oracle update that accepted signed price reports of any age
On September 16, 2026, at 12:37:35 UTC, the price of PRFI stored in PrimeFi's lending market on HyperEVM went from about $0.0021 to about $0.1101 inside a single transaction, roughly 52 times higher, without any market moving. An attacker had handed PrimeFi's oracle contract two price reports carrying valid Chainlink signatures, and the contract wrote them into storage as the current price.
By the end of that transaction, 425.52 WHYPE, about $33,400, had left PrimeFi's WHYPE reserve, borrowed against PRFI collateral valued at the inflated price. The function that accepted the reports, verifyReport(), could be called by anyone and never checked how old a report was.
PrimeFi, run by Prime Numbers Labs, is a lending and borrowing protocol with markets on HyperEVM. Users supply assets to earn yield or post collateral to borrow, and every loan's health depends on the price the protocol holds for each collateral asset. PRFI, PrimeFi's own token, was one of the collateral assets, and PrimeFi priced it through Chainlink, which Chainlink's announcement describes as a DataLink integration for PRFI.
That kind of feed works on a pull model. Chainlink's oracle network signs price reports at a moment in time, and a consumer contract on the destination chain verifies the signature and stores the price when someone submits a report. Each report carries the time it was observed, and it's up to the consumer to decide which reports are recent enough to trust.
PrimeFi's consumer contract, DataStreamConsumer, exposes verifyReport(bytes). According to the DeFiHackLabs write-up, the function forwards the payload to Chainlink's verifier, which confirms the signature is genuine, and then overwrites the stored price. The contract is Ownable, but the owner check only guards configuration setters. verifyReport() has no access restriction and no check on the report's timestamp, so any report with a valid signature, from any point in the past, could be submitted by any address and become the price.
That's the idea worth taking away from this one: a signature proves who said something, and freshness is what proves it still applies. A consumer that checks only the signature will accept yesterday's truth as today's. It's like a bank accepting a signed check without looking at the date, where every signature is real and some of the checks are years old.
The Chainlink side worked as designed throughout. The reports were authentic and the verifier confirmed it. The gap was in what PrimeFi's consumer did after verification, in a function where the price written to storage feeds straight into how much a borrower can take out.
The attacker's address, 0x19bc...5a52, ran the whole sequence in transaction 0xff99...4243, through a contract at 0x817D...6Da1 that it deployed and called inside that same transaction, in HyperEVM block 46060987. It started with a 100 WHYPE flash loan from Morpho Blue, a loan that has to be repaid before the transaction ends. It then called verifyReport() twice with signed reports that put PRFI at about $0.1101, and the stored price jumped about 52 times.
Next it bought 795,587 PRFI from a thin WHYPE/PRFI pool on HyperswapPair for about 26.82 WHYPE, deposited that PRFI into PrimeFi as collateral at the inflated price, and borrowed WHYPE against it. The borrow drained 425.52 WHYPE from the reserve. The attacker repaid Morpho in the same transaction and kept the rest, about 398.70 WHYPE in profit as reported, with the DeFiHackLabs proof of concept reproducing about 397.02 WHYPE.
Defimon's alert put the loss at about $33,400. The WHYPE reserve that funded the borrow belonged to PrimeFi's lenders.
Olympix reads a contract the way an attacker does, as states, transitions and entry points, and it takes in the context around the code, such as which assets are collateral and where their prices come from, to infer the invariants a lending market relies on but never writes down. For PrimeFi, the invariant is one sentence: a borrower's collateral should only be valued at a price that's current, so no caller can make collateral look worth more than the market says.
A contract's state space looks infinite, but it isn't, and the engine maps every path and uses signals to decide which ones to attack. Olympix's static analysis surfaces the signal here: an external function, callable by anyone, that writes an oracle price into storage with no check on the report's age between verification and the write. That narrows the search to the paths where an attacker-supplied report reaches the stored price and then reaches a borrow. Olympix has flagged this class before in other codebases, oracle data accepted without validating when it was produced.
BugPoCer starts from the lending market's books: Counterexample-Guided Invariant Refutation holds the collateral-pricing rule fixed and executes paths through verifyReport(), deposit and borrow until some sequence lets a caller take out more than their collateral is worth at market. The engine's other method, Bounded Adversarial Verification in BugScout, begins at the flagged storage write and tries known oracle-manipulation strategies against it, and both rely on the engine's symbolic execution. The counterexample for PrimeFi is the exploit in order: an older signed report submitted through verifyReport(), PRFI deposited at the new price, and a borrow that exceeds what the collateral is worth at market. Olympix returns that sequence, the minimal conditions that trigger it and a generated Forge test that replays it, so the September 16 drain shows up in development instead of on HyperEVM.
Olympix runs automatically in development, at every merge and before release, which is where an oracle integration like this one meets the lending code that trusts it.
PrimeFi's oracle provider signed honest reports and its verifier checked them correctly, and the loss came from a consumer that treated a valid signature as proof of a current price and let anyone submit one. Every pull-based price integration carries that same decision about who can push a price and how old it may be. To see how Olympix tests the path from your oracle to your borrow logic, book a technical walkthrough.
Protocol: PrimeFi (Prime Numbers Labs)
Chain: HyperEVM
Date: September 16, 2026, 12:37:35 UTC (block 46060987)
Loss: 425.521620381705945356 WHYPE drained from the reserve (about $33.4K)
Attacker EOA: 0x19bc...5a52
Exploit tx: 0xff99...4243
PRFI token: 0x7bbc...3255
Attack contract: 0x817D...6Da1
DataStreamConsumer (oracle, vulnerable): 0x04ED...2bE6
Lending pool (victim): 0xb339...113F
aWHYPE (WHYPE reserve holder): 0xCF46...48Ba
Chainlink Verifier proxy: 0x60fa...e9eb
WHYPE/PRFI pool: 0x981F...5515
Morpho Blue (flash loan source): 0x68e3...57cD
Block: 46060987
Defimon Alerts: original alert on X
DeFiHackLabs PR #1267: PrimeFi exploit proof of concept
Chainlink via OKX: PrimeFi integrates Chainlink DataLink for PRFI pricing