Hyperbridge lost $2.5M to a missing bounds check, with $0.74 of gas
A bridge built specifically to replace multisigs with cryptography lost $2.5M in April 2026. The attacker's gas cost was about $0.74. That number is not a typo, and it is the whole point: the protocol's architecture
A bridge built specifically to replace multisigs with cryptography lost $2.5M in April 2026.
The attacker's gas cost was about $0.74.
That number is not a typo, and it is the whole point: the protocol's architecture was fine. It verified zero-knowledge proofs from a Polkadot light client, which is a genuinely harder and better design than a 5-of-9 multisig. The failure was a bounds check.
The setup
Hyperbridge connected Polkadot to Ethereum using proofs instead of committees. Instead of trusting a set of signers, the contract verified a Merkle Mountain Range proof against a known historical state, then executed whatever the verified message said.
The proposition was clean: math instead of trust. No more Ronin-style key compromises.
On April 13, 2026, someone read the verifier.
The bug
VerifyProof() in HandlerV1 had one job: confirm the MMR proof is valid for the claimed state. It checked the root, the leaf hash, the position.
It did not check that leaf_index < leafCount.
That single missing comparison is the entire vulnerability. With leafCount = 1 and leaf_index = 1, the root calculation skipped the actual leaf hashes and accepted a value supplied by the caller.
Read that again, because it is subtle and it generalises: the verifier computed a root from data the attacker provided, then compared it to something derived from the same data. That is not a check. That is arithmetic agreeing with itself.
The second failure
A valid proof is not a valid action. The contract verified that some state existed at some point, then executed the request attached to it — but the proof and the request were never bound together.
So the attacker took a legitimate historical proof and attached a malicious request. The proof still verified. The message said whatever the attacker wanted it to say.
From there the path ran straight through the system:
- Fake proof accepted.
-
onAccept()→handleChangeAdmin()— admin control over the bridged DOT contract, granted instantly, no timelock. - Minted 1 billion bridged DOT in a single transaction.
The legitimate supply was about 356,000 DOT. The attacker minted 2,805 times that, with no supply cap and no pause.
Three independent controls were missing, and they compounded: a forged proof passed, an admin transfer executed immediately, and a mint had no ceiling.
The exit and the damage
The billion fake DOT moved through Odos and Uniswap V4 for roughly 108.2 ETH, about $237K up front. The rest of the damage came from drains across Base, BNB Chain and Arbitrum incentive pools, bringing the total to around $2.5M.
Upbit and Bithumb suspended all DOT deposits and withdrawals. Every LP position backed by bridged DOT was worth nothing overnight.
What this actually proves
The bridge security thesis of the last three years has been architectural: replace the multisig with proofs, and the attack surface shrinks from "who holds the keys" to "is the math wrong". That thesis is still correct, but this case is the counterexample people should read, because it shows where the risk actually migrated.
It moved from the design to the implementation details nobody writes a test for:
- Does the verifier reject out-of-range indices?
- Is the proof bound to the message it authorises, or sitting next to it?
- Can an admin role change hands without a delay?
- Is there a supply cap on the minted representation?
Every one of those is one line of code or one config value. None of them is cryptographic. All of them are what decides whether the bridge holds.
The same month produced Syscoin (~$8M, UTXO validation bypass) and Aztec Connect ($2.19M, a mismatch between what the ZK proof verified and what the L1 settlement code did with it). Three bridges, three mechanisms, one shape: the verification and the action were not the same object.
The line worth remembering
A proof that is valid tells you the state was real.
It does not tell you that the request attached to that state was ever permitted, and it certainly does not tell you the verifier was asked the right question.
If you are building a bridge, the review question is not "do our proofs check out". It is: what exactly does a passing proof authorise, and is that object inside the proof?
This is one of 61 on-chain case investigations, indexed at qanzhi111.github.io/intel.
The archive. 61 on-chain investigations and 64 days of GitHub leak scanning, redacted and never used. Read the index or try the free token risk check at qanzhi111.github.io.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.
