Skip to content
Crypto.world

Research

Lessons Not Learned: Why Cross-Chain Bridges Keep Losing Billions the Same Way

Catalogues 2021-2026 bridge losses, attributing 88% since 2023 to posture failures audits miss, and ships an on-chain rubric analyzer that makes bridge due diligence checkable.

Lessons Not Learned: Why Cross-Chain Bridges Keep Losing Billions the Same Way
arXiv
2611.12252
Published
2026-11-09
Authors
Mohsen Ahmadvand, Piotr Dobaczewski, Camille Bouzerand

AI summary

Overview

Research area: Blockchain security — cross-chain bridge security, incident forensics, and on-chain risk assessment.

Technical level: Intermediate. The paper is readable without deep cryptography background, but it assumes familiarity with how bridges, multisigs, timelocks, proxies and verifiers work.

Scope (one sentence): The paper catalogues 72 cross-chain bridge incidents from June 2021 to July 2026 ($3.52B in reported losses), traces each to the failed component, and turns the recurring failures into a scored, on-chain-evidence-based assessment rubric plus two analyzers (a bespoke per-stack analyzer with live monitoring, and an agentic analyzer).

What This Paper Is About

Most bridge hacks do not exploit a code bug. They exploit how a bridge is set up — who holds the keys, how many signers must approve a release, what the bridge trusts off-chain, and what limits exist once something goes wrong. The authors call this "security posture," show that posture failures account for 88% of reported losses since 2023, and argue that code audits structurally cannot catch them. Their goal is a rubric that scores a deployed bridge from on-chain evidence, caps the score when a fatal weakness is present, and measures a token by its weakest deployment on any chain.

Key Contributions

  1. An incident catalogue with root-cause attribution. 72 bridge incidents from June 2021 to July 2026 with $3.52B in reported gross losses, each traced to the specific dependency that failed (people, code, controls, or off-chain infrastructure), plus 7 cases where a flaw was found or an attack stopped before any funds were lost, at $0.

  2. A counterfactual loss model. Each hack is replayed under different defenses. Rate limits and an emergency stop alone cut losses from $3.52B to $123M (28.6-fold); combined with the rubric's posture controls, losses fall 105-fold to $33M.

  3. A bridge security assessment rubric. 26 weighted questions across four categories (People & Power at weight 40, Code & Config at 35, Controls & History at 25, Off-chain Infrastructure at 15), scored 1–5 per deployment, with five hard caps that drop the score to 1 when a fatal risk is present, plus four unweighted questions (Q27–Q30) on cryptographic breaks. A token is scored at its weakest deployment across every chain that can mint it or release its backing.

  4. Two working analyzers plus monitoring. Bespoke analyzers covering the seven bridge stacks used by 37 tokens on Monad, reading all values at a fixed block per chain so reports are reproducible, with a monitor that re-runs assessment when watched configuration changes; and an agentic analyzer that runs the same checks on any bridge, matching the analyzer's answer on 94.6% of the answers the analyzer decides and re-checking an unchanged bridge at no further model cost.

Main Findings

  • Posture, not code, dominates recent losses. Posture failures account for 88% of reported losses since 2023. Before 2023, most reported losses came from code defects.
  • Failures repeat. Every posture failure since 2023 repeats a kind already seen by 2022.
  • Four recurring posture failure classes. Quorum compromise (11 hacks, $1,095.0M), attester forgery (7, $317.6M), admin-key compromise (10, $175.7M), and frontend hijack (1, $0.2M) — a posture subtotal of 29 hacks and $1,588.5M. Code bugs account for 43 hacks and $1,933.1M, for a total of 72 hacks and $3,521.6M.
  • The rubric catches all known posture hacks. All 29 posture failures are flagged: a hard cap fires on 28 (Quorum on 17, Authority on 11, Backing on 7, Provenance on 6), and the remaining one — Celer's hijacked website — takes the lowest tier of the website question (Q21), which has no cap.
  • Most weaknesses were visible beforehand. For 21 of the 29 posture failures the weakness was readable on chain before the attack; the other 8 were off-chain.
  • The KelpDAO case. The April 2026 incident lost $292M on LayerZero OFT contracts that had been audited repeatedly, because one deployment accepted messages approved by a single decentralized verifier network whose RPC feed was poisoned. The single-DVN setting was public on chain before the exploit; a rate limit and a stop would have held the loss to $1.04M.
  • Containment works but needs time. With a $1M allowance refilling at $1M per day and a stop after one hour, the loss bound is about $1.04M; Ronin and KelpDAO each fall to $1.04M under the model.
  • Privileged changes precede drains. In 4 of the 7 hacks with known timing, the drain followed within an hour of the privileged change, which is why the rubric's Authority cap requires at least one hour of delay and its top upgrade-delay tier requires 48 hours.
  • Tier ordering holds. On all 48 tier steps that change what an attacker can take, the higher tier loses less in the loss model and never more, for one setting of each tier on a declared set of attacks.
  • Agentic parity. The agentic analyzer reproduces the analyzer's answer on 94.6% of the answers the analyzer decides.

Methodology in Plain English

The authors started from the hacks rather than from theory. AI agents gathered reports from hack databases and security-firm write-ups, then searched again for missed incidents; a second pass rechecked every amount and cause against the original sources, and every entry was verified. Each hack got one classification test: did the bridge's code do what it was written to do? If not, it is a code hack (Wormhole, where signer keys stayed safe but signature checking was buggy). If yes, it is a posture failure (Ronin, where the contract correctly released on five of nine valid signatures — and the attacker held five keys).

From those root causes they built two things. First, a rubric: each recurring failure becomes a question with tiers running from the setting found at real hacks (tier 1) to the setting that blocks them (tier 5), decided from on-chain reads and public evidence, with hard caps for weaknesses that are fatal regardless of everything else. Second, a counterfactual loss model that replays each historical hack under changed defenses, so the benefit of a rate limit, an emergency stop, an upgrade delay or a higher tier can be quantified rather than asserted.

They then engineered the rubric into analyzers. A registry lists every bridge and token on Monad with its contracts on every chain. Each bridge stack gets its own adapter that knows where its contracts store the values each question needs, and every read for one report comes from a single pinned block per chain, so a rerun gives an identical report. A monitor watches the specific on-chain events that should trigger a fresh assessment.

Why This Matters

Impact on research. The paper reframes bridge security from "find the bug" to "measure the configuration," and ties each historical loss to the dependency whose failure caused it — a link the authors argue existing hack surveys and registries do not make. It also supplies something rare in bridge risk frameworks: a scale tested against realized losses, with 48 tier steps checked for monotonicity.

Real-world applications:

  • Bridge and protocol operators get a concrete fix list: keep the keys that move assets separate from the keys that stop the bridge, limit every path that can release funds, and monitor changes to those keys and limits.
  • Users, wallets and applications can compare bridges by who can move their funds and which controls bound a loss, rather than by audit logos.
  • Institutions and allocators get a weakest-link view — a token is only as safe as its weakest deployment on any chain that can mint it or release its backing, even a chain the holder never uses.
  • Live monitoring and alerting for configuration drift, since most drains with known timing followed a privileged change within an hour.

Industry relevance. The paper targets the gap left by L2BEAT, DeFiSafety, the Crosschain Risk Framework, Quantstamp's rollup framework and contract-assurance standards, which the authors say rate design trust, process quality or implementation quality, score one deployment at a time, and do not test their scales against losses. Because rate limits and an emergency stop bound losses from any attack, the authors apply containment even to code bugs, which are otherwise outside the rubric.

Future Directions

  • Validating the cut-offs. The specific thresholds — 48 hours on upgrades, 5% of backing per day on rate limits, one hour for the Authority cap — are the authors' own judgment, and they flag this explicitly as a limitation.
  • Scoring the off-chain questions automatically. The bespoke analyzer answers 17 questions from contract state and on-chain events; nine scored questions depend on audits, public monitoring, incident history, the website and how off-chain signers actually run, and the four cryptographic-resilience questions need reasoning about each privileged path rather than fixed reads.
  • Broadening coverage beyond posture. Code bugs, economic attacks and issuer powers are outside the rubric; whether those can be folded into the same scored, cap-based structure is open.
  • Extending the agentic analyzer. It currently matches the bespoke analyzer on 94.6% of decided answers and re-checks unchanged bridges at no further model cost; generalizing it to arbitrary bridges at higher coverage is the obvious next step.

Target Audience

Bridge and protocol security engineers, smart-contract auditors, and risk analysts at funds and institutions who need to compare bridges on something more decision-relevant than audit count. It is also useful for L2 and ecosystem teams deciding which bridge stacks to list, for incident-response and monitoring teams, and for researchers studying DeFi security measurement, since the catalogue and counterfactual model are reusable even by readers who do not adopt the rubric itself.

Authors’ abstract

Bridge hacks have cost billions, often without exploiting a code bug. In the cross-chain bridge hacks we catalogue from 2021 to 2026, failures of security posture, meaning how a bridge's people, code, controls and off-chain infrastructure are set up, account for 88% of reported losses since 2023, and nearly all repeat earlier failures. Code audits cannot catch these failures, so we propose a bridge security assessment rubric. It scores each bridge deployment from on-chain…

The full abstract on arXiv
Read the original paper