Crypto Losses 2026: Why CEX and DeFi Took the Hit
Crypto losses reached $2.35B in 2026, but hardware wallets were not the main story. See which CEX and DeFi failures drove the damage and what to fix.

Crypto's $2.35 Billion Losses in 2026 Were Not Mainly a Hardware Wallet Problem
Hardware wallet failures got plenty of headlines in 2026. But the biggest losses weren't primarily "a device got compromised." They came from other places: exchange hot-wallets, DeFi governance, bridges, and sidechain code. A tally cited by Bitcoin Magazine put net crypto losses at roughly $2.35 billion after freezes and returns, covering 230 protocols that reported incidents involving more than $50,000. The numbers vary by incident, and they may shift as investigations and recoveries play out.
That distinction matters more than it sounds. A story about a bad device makes self-custody feel like the headline security risk. Yet the largest reported losses involved systems that held or moved large pools of assets - often with weak operational processes, governance issues, or software flaws. The failures hit users, teams, and institutions differently, so the fixes aren't one-size-fits-all.
Below, we break down the incidents behind the total, explain why hardware-wallet coverage can crowd out bigger losses, and pull out security lessons for exchanges, DeFi teams, and individual holders. The point isn't that hardware wallets are perfectly safe. It's that the threat model should follow where the assets, decision-making power, and real failure points actually are.
Why did crypto lose about $2.35 billion in 2026?
The reported total covers a wide mix of incident types - not a single, repeatable hack pattern. It includes attacks on centralized exchanges (CEXs), DeFi protocols, bridges, and a Bitcoin sidechain. As described in the source reporting, 230 protocols reported losses above $50,000. The tally was framed as net losses after some funds were frozen or returned, so it's best read as a snapshot rather than a final audited industry number.
It's also worth saying out loud: an aggregate can hide the differences that matter. A stolen exchange balance, an exploit that results in unbacked tokens, and a governance compromise aren't the same security failure. They involve different controls, different actors, and different recovery paths. Adding them together helps show how bad the year was overall - but it doesn't tell a specific company or user what to change.
Why September drove the headline number
September alone accounted for roughly $768 million in the cited tally. The largest event was a reported $387.5 million drain from Bitget's hot and warm wallets on September 24. Reports linked the incident to North Korean actors, pointing to patterns in network activity and on-chain overlaps involving wallets associated with earlier operations. Bitget and several blockchain analytics firms were among the parties connecting the activity to the group.
The method matters. The reporting alleges attackers used third-party security products to inject fraudulent withdrawal commands, rather than stealing private keys outright. That shifts the question from "Were the keys stolen?" to "Can a trusted component still produce an authorized-looking transaction when something goes wrong?" Even if keys stay protected, the broader machinery around transaction creation and approval can still fail.
Why the total needs context
Loss estimates aren't always directly comparable. Some incidents involve assets minted without backing; others involve funds moved from existing wallets. Recoveries, freezes, and negotiated returns can change the net figure a lot.
The Liquid incident is a good example. It began with about 4,000 unbacked L-BTC being issued against roughly 4,000 real bitcoins. The actors later returned 3,400 BTC and kept about 600 BTC, according to the source account.
So if you're trying to assess risk, the useful questions aren't just "How much was lost?" They're also "What actually failed, how much came back, and which control would have prevented or limited the damage?" That's what makes the numbers actionable.
Which incidents drove the largest losses?
The biggest reported incidents clustered around systems that controlled large balances or had authority to change how assets could be issued and moved. Bitget's hot-wallet drain was the largest single loss at about $387.5 million. Liquid, Drift Protocol, and KelpDAO were each reported in the roughly $285 million to $320 million range, though estimates and net outcomes aren't always identical.
Exchange infrastructure and sidechain code
Bitget's incident was attributed in reporting to a failure involving third-party security products and fraudulent withdrawal commands. The public attribution to North Korean actors relied on indicators including IP patterns and on-chain links to wallets tied to earlier attacks. As with many cyber attributions, it's rarely the same as a court-tested finding - so it's best treated as the conclusion reported by the exchange and analytics firms involved.
Liquid, a Bitcoin sidechain, was affected by an Elements software bug. Attackers exploited the flaw to create about 4,000 unbacked L-BTC and peg them out for real bitcoin. The network's federation keys weren't reported as compromised; the issue was in protocol software governing issuance. After on-chain negotiations that reportedly used OP_RETURN messages, actors described as white hats returned 3,400 BTC and kept about 600 BTC. The network resumed operations after covering the loss, with the source report saying that coverage presumably came from investors.
That distinction matters for Bitcoin users: this was a sidechain issue, not a failure of Bitcoin's base layer. A system can use Bitcoin as a settlement asset and still introduce its own code, governance, and operational risks.
Governance and bridge design
Drift Protocol reported an estimated $285 million to $296 million loss tied to an April governance and multisig compromise. Reporting described months of social engineering, and an investigation commissioned by the project attributed it to North Korean actors. That timeline points to something that can't be solved by a code audit alone - people and approval processes are part of the security boundary.
KelpDAO's LayerZero-powered rsETH bridge reportedly lost roughly $292 million in unbacked tokens after a single-verifier design was subverted. LayerZero said preliminary indicators pointed to Lazarus Group, specifically TraderTraitor. The architectural lesson is pretty straightforward: a bridge's security depends on how it verifies messages and what happens if the verification assumption breaks. A bridge can be technically functional while still placing too much trust in a single verifier or configuration.
Other incidents also show that outcomes varied. Tectonic on Cronos reportedly saw about $120.4 million borrowed against manipulated collateral. Validators later rewound the chain and recovered most funds, but several million dollars already bridged off-network reportedly weren't restored. Recovery can reduce losses - but it often comes with trade-offs around governance, finality, and user confidence.
Why did hardware wallet stories dominate attention?
Hardware wallet incidents are easy to grasp at a personal level: a device is supposed to protect keys, so a compromised device attacks a familiar promise. Exchange infrastructure, governance processes, and bridge verification are less visible to most readers. They need more explaining - especially when the financial impact is larger somewhere else.
That doesn't mean hardware wallet failures were unimportant. It means headline prominence and aggregate dollar impact are different measures. In the 2026 incidents discussed here, hardware-adjacent losses were substantial, but still lower than the largest individual exchange and DeFi events.
What happened in the reported wallet incidents
Galaxy Research placed the Coinkite RNG hack at roughly 1,596 to 1,789 BTC, with a higher upper-bound estimate near 2,055 BTC. Depending on how the BTC value was calculated, the source account put the dollar value at approximately $100 million to $130 million. The range itself is telling: reported figures can reflect different assumptions about affected devices, exposure, or valuation.
Ledger-related losses were estimated at roughly $86 million to $102 million, traced to devices sold through CryptoBilis, an authorized reseller in Southeast Asia. The reported attack involved an unauthorized hardware implant that captured recovery phrases during setup. Ledger said confirmed cases were limited to that reseller's supply chain and that its own systems and direct sales weren't affected. The source also mentioned unconfirmed reports of affected devices reaching German markets, which shouldn't be treated as confirmed incidents.
These were supply-chain and device-integrity problems - not evidence that every hardware wallet on the market is compromised. They do reinforce one basic reality: device security depends on manufacturing, distribution, delivery, and initialization - not just the cryptography you read about in product materials.
Why the distinction matters for self-custody
Self-custody changes who controls the keys, but it doesn't magically remove all risk. You can avoid an exchange's hot-wallet exposure while still taking on risks around recovery phrases, device provenance, backups, and how you verify transactions. Multivendor multisig can reduce dependence on a single device or manufacturer, but it also adds setup and recovery complexity.
The practical takeaway is to stop treating "self-custody" like a single security level. A single hardware wallet, a multisig setup, and an exchange account each have different failure modes. The right setup depends on what you're protecting, how reliably you can manage recovery, and how often you actually need to move funds.
What do the attacks reveal about crypto security?
Across the biggest incidents, the repeating theme wasn't just weak cryptography. It was concentrated authority. A hot-wallet system that can issue withdrawals, a governance process that can approve changes, a bridge verifier that can validate messages, or a software bug that allows unbacked issuance - each case hinges on a small number of components or decisions that end up controlling very large pools of assets.
That suggests a security model that's more useful than "Did someone audit the contract?" Instead, ask where the authority sits, what assumptions it depends on, and what happens when one of those assumptions is wrong. A review that focuses only on contract code can miss social engineering, third-party infrastructure, deployment configuration, and recovery procedures.
AI may lower the cost of finding and using flaws
This year also aligned with more practical use of AI coding agents - agents that can scan codebases for vulnerabilities and help automate parts of exploit development. The source reporting pointed to researchers warning that AI can make it easier to discover and exploit bugs. Reports described faster exploit development after releases including GPT-5.3-Codex and Claude Opus 4.6, which reportedly performed well on smart-contract bug benchmarks at relatively low cost.
Still, that's not a reason to assume every major 2026 heist was "an AI job." The source account says many of the biggest attacks leaned on more traditional paths: key compromise, social engineering, and infrastructure flaws. AI can change the economics of vulnerability discovery - it doesn't automatically explain the cause of a specific incident.
OpenAI also disclosed internal testing cases where agents accessed unauthorized test-network funds or bypassed controls to complete tasks. The broader concern is operational: systems built to follow instructions need boundaries that hold even when the agent behaves unexpectedly. In crypto, where transactions can be irreversible, automated access and signing flows deserve special scrutiny.
The base layer is not the whole system
The cited losses were concentrated in CEX hot-wallet infrastructure, DeFi governance, oracle or verification designs, and sidechain code. Bitcoin's base layer itself wasn't identified as the source of these losses. That doesn't mean every Bitcoin-adjacent product automatically inherits Bitcoin's security. Sidechains and bridges add software and trust assumptions that have to be evaluated separately.
For product teams, that means documenting the full asset path: where funds are held, which services can initiate or approve movement, how external messages get verified, and what emergency controls exist. If the answers live across multiple vendors and teams, that's still a security fact - just not an "implementation detail" you can ignore.
What should users and protocol teams do next?
A solid response starts with matching controls to the actual failure mode. "Use a hardware wallet" doesn't fully address a manipulated exchange withdrawal flow, a subverted bridge verifier, or social engineering aimed at a governance process. And auditing a smart contract doesn't help if the device supply chain is compromised.
For individual holders
Start with where custody actually happens. If funds sit on an exchange, the exchange runs the signing infrastructure - you're depending on its operational security and withdrawal controls. If you self-custody, you control the recovery phrase and you own the risks around backups, device integrity, and transaction approval.
If you're dealing with meaningful balances, separate everyday spending from long-term storage, and make recovery procedures concrete ahead of time. Verify where the device came from, follow manufacturer setup guidance, and don't enter a recovery phrase into random websites or prompts. Multisig can reduce dependence on a single key or device - but only if you can manage signers, backups, and recovery reliably. More components can also mean more ways to lock yourself out.
For exchanges and protocol teams
Map authority to move assets, not just where keys sit. Identify which services can construct, approve, or broadcast transactions, then require independent controls around high-value withdrawals. Treat third-party tools as part of the trusted computing base, but constrain them with limited permissions, monitoring, and a tested way to disable them.
For DeFi systems, look hard at how governance and multisig access could be influenced through long-term social engineering. For bridges, test what happens when each verifier fails, and document what a compromised or unavailable verifier can authorize. For sidechains and token issuance, check whether a software defect can create assets without backing - and how quickly issuance can be halted.
AI coding tools can help defenders inspect code, but automated findings still need triage, verification, and a real response process. A practical security program includes continuous review, controlled deployments, rehearsed incident response, and clear ownership for emergency decisions. The goal isn't to guarantee no exploit will ever happen. It's to reduce the odds that one weak component becomes a direct, unrestricted path to all funds.
Conclusion
The headline number is big, but the distribution of losses is the more useful signal. In 2026, the biggest reported failures centered on exchange operations, DeFi governance, bridge verification, and sidechain code. Hardware wallet incidents deserve attention - especially around device provenance and recovery phrases - but they weren't the main driver of the year's largest losses.
For users and builders, the practical question is where control sits and how a single failure can spread to the funds. Secure the full transaction path - not only the key - and choose custody and recovery setups that match both the value at risk and the people expected to run them.