The ICON Foundation was drained of 119,866,000 ICX and 531,600 bnUSD in a replay attack that exploited a silent float64 precision bug. The real story isn’t the loss—it’s what the attack reveals about the broken audit pipeline and the liquidity illusion of centralized relayers.
Context: The Infrastructure Layer That Failed
ICON is a Layer-1 blockchain that positions itself as a cross-chain hub. Its relayers process withdrawal messages between chains. On the surface, the network seemed robust. But in November 2025, a postmortem revealed that a change to standardize withdrawal messages to 32 bytes introduced a subtle flaw. The sequence number was processed through float64 logic instead of exact integer arithmetic. The result: precision loss. The attacker could modify the high bits of the identifier without altering the signed payload, bypassing the uniqueness check while keeping the cryptographic signature valid.
This is not a new attack vector. Replay attacks are classic. But the root cause here is a mismatch between which parts of the data are verified by the contract’s uniqueness check and which parts are signed. The uniqueness check looked at the mutable high bits. The signature covered the unchanged low 256 bits. The attacker exploited this gap to replay 1,490 withdrawal messages.
Core: The Code That Wasn't Audited
I have spent the last eight years auditing blockchain protocols. The first thing I look for is consistency between verification and state change. In this case, the contract checked uniqueness on a field that the attacker could modify, while the signature validated a field that remained static. That is a design flaw that any competent auditor should flag. Yet the November 2025 relay audit—the one that was supposed to catch this—missed it entirely. The audit report listed nine findings, none related to sequence number mismatches.
This is not a failure of the auditor alone. It is a failure of scope. The audit likely did not cover the affected migration contract source code. The ICON team changed the withdrawal message format, but the audit process did not trace the impact of that change through the entire codebase. The result is a blind spot that cost the foundation over 100 million ICX.
Algorithms don't fail—they behave exactly as they are coded. The algorithm here was correct: it verified the signature, it checked uniqueness. But the two checks operated on different logical domains. The contract assumed that the signed payload and the uniqueness identifier were the same set of bytes. They were not. This is the kind of error that emerges when developers treat integer types as interchangeable. Float64 for sequence numbers? That is a rookie mistake in a protocol that handles millions of dollars.
Let me be clear: precision loss in financial contracts is a capital crime. The Ethereum ecosystem learned this after the DAO hack. Solidity developers now use SafeMath libraries. But ICON’s Java-based smart contract environment allowed this classic error to slip through. Yield is just rent for your ignorance. The ignorance here is assuming that a change to message standardization does not require re-auditing the entire verification pipeline.
The Attack Timeline: A Liquidity Cascade
The attack began at 02:23 UTC. The monitoring system alerted at 02:30—seven minutes later. But the contract was not paused until 04:08. That is 105 minutes of active exploitation. During that window, the attacker drained the funds and began dispersing ICX to exchanges. By the time the pause went into effect, the attacker had already established exit liquidity.
This is where the macro watcher in me warns: exit liquidity is a social construct. The attacker assumed that the exchanges would process the withdrawals. Most did. Bitvavo, Bitget, and KuCoin froze deposits and withdrawals after the incident, but the initial transfers had already been made. The net loss was eventually pegged at 150.2 ETH and 31,204 USDC after recoveries—a fraction of the total released. But the fact that the attacker could move funds to centralized exchanges so quickly underscores the fragility of the bridge between on-chain logic and off-chain liquidity.
Contrarian: The Decoupling Thesis Is Wrong
Some analysts will argue that since user funds were not affected and most assets were recovered, the event is a minor blip. They will point to the quick alert and the pause as evidence of a competent response. I disagree.
This attack is a structural failure. It exposes a systemic weakness in how the industry audits cross-chain infrastructure. The problem is not that ICON lost money—it is that the loss was caused by a bug that should have been caught in a code review, let alone an audit. If the migration contract was not audited, then the entire cross-chain bridge was effectively running on unaudited code. That is not a minor blip. That is a governance failure.
Moreover, the release of 119 million ICX onto the market—even if mostly recovered—creates a liquidity overhang. The foundation now holds a large amount of ICX that was previously locked. Market participants will price in the risk of future sales. The token’s security narrative has been broken. And trust is the hardest asset to recover.
Takeaway: The Cycle of Audits and Ignorance
Every bear market teaches us that security is not a feature—it is a process. The ICON incident is a textbook case of process failure. The money printer of cross-chain interoperability giveth, and the political economy of angle check taketh away. The market will forget this event in three months, but the code will not forget. The next time a relayer changes a message format, someone will remember the float64 precision bug.
For investors, the signal is clear: do not trust audits that do not cover the full attack surface. For builders, the lesson is: every change to a signed message format must be treated as a new attack vector. The only way to survive this cycle is to assume that every piece of code is vulnerable until proven otherwise by adversarial testing. Algorithms don't—they behave exactly as they are coded. But the people who code them? They are the ones who need to learn.