Skip to main content

Resolv Hack: How One AWS Key Minted $25M and Broke DeFi Again

· 10 min read
Dora Noda
Dora Noda
Software Engineer

On March 22, 2026, an attacker walked into Resolv Labs with $100,000 in USDC and walked out with $25 million in ETH. The smart contracts never bugged out. The oracle never lied. The delta-neutral hedging strategy behaved exactly as designed. Instead, a single AWS Key Management Service credential — one signing key that lived outside the blockchain — gave an intruder permission to mint 80 million unbacked USR tokens against a $100K deposit. Seventeen minutes later, USR had fallen from $1.00 to $0.025, a 97.5% collapse, and lending protocols across Ethereum were absorbing the shock.

The Resolv incident isn't remarkable because it was clever. It's remarkable because it wasn't. A missing max-mint check, a single point of failure in cloud key management, and oracles that priced a depegged stablecoin at $1 — DeFi has seen each of these failures before. What the hack reveals is uncomfortable: the attack surface of modern stablecoins has quietly migrated from Solidity to AWS consoles, and the industry's security models haven't caught up.

Anatomy of a 17-Minute Heist​

Resolv's minting flow was a two-step off-chain dance. A user called requestSwap() to deposit USDC. A privileged off-chain signer — the SERVICE_ROLE — reviewed the request, decided how much USR to issue, and called completeSwap() to finalize the mint. The contract enforced a minimum output but no maximum. Whatever the key holder signed, the contract honored.

That design put the entire integrity of a $500M+ TVL protocol behind a single private key stored in AWS KMS. When the attacker compromised Resolv's cloud environment and gained access to the KMS-held signing credential, the rest of the exploit was almost mechanical:

  1. Deposit roughly $100K–$200K of USDC through requestSwap()
  2. Use the stolen SERVICE_ROLE key to sign a completeSwap() authorization for 80 million USR
  3. Rotate the minted USR through wstUSR (the staked wrapped variant) to soften initial market impact
  4. Drain liquidity through Curve, Uniswap, and KyberSwap, converting to ETH

By 02:38 UTC, USR was trading at $0.025 on Curve — a 97.5% depeg. The attacker's wallet ended up holding approximately 11,400 ETH, worth roughly $24 million at the time. The whole operation took 17 minutes, start to finish.

The Off-Chain Attack Surface Nobody Audits​

Here's what's striking: Resolv had been audited. Its Solidity code was not the problem. Reentrancy guards, integer overflow checks, logic reviews — all clean. The exploit ran exactly the codepath the engineers designed.

The vulnerability lived one layer up, in the cloud infrastructure that controlled minting authority. Modern DeFi protocols are not purely on-chain systems. They lean on off-chain price feeds, off-chain keepers, off-chain governance multisigs, and — as Resolv demonstrates — off-chain signing services hosted on cloud platforms. Standard smart contract audits review the on-chain code. They do not audit AWS IAM policies, KMS key rotation schedules, environment variable hygiene, or the blast radius of a compromised CI/CD pipeline.

The Chainalysis post-mortem put the lesson bluntly: "The next exploit may come from a phishing email, a misconfigured IAM policy, or a leaked environment variable." In other words, the hardest-to-secure piece of a modern stablecoin is not its bonding curve or its collateral ratio. It's the cloud account that holds the minting key.

Three design choices compounded the risk at Resolv:

  • No maximum mint check on-chain. The contract trusted the off-chain signer completely. Even a simple "no single mint can exceed 5% of total supply" rule would have capped the damage at a few million dollars instead of $25M.
  • No rate limiting. Nothing in the minting logic noticed that 80M tokens had just been issued in one call against a deposit orders of magnitude smaller.
  • No multi-party authorization. A single SERVICE_ROLE signature — not a threshold signature, not a multisig — was sufficient to finalize a mint of any size.

Any one of those controls would have turned the incident into an inconvenience instead of a catastrophe.

The second half of the Resolv story is where the damage multiplied. USR and its staked wrapper wstUSR had been adopted as collateral across several large lending markets: Morpho, Euler, and Fluid/Instadapp. When the stablecoin collapsed, those markets' oracles kept pricing wstUSR near $1 — either because they used internal redemption rates rather than market quotes, or because the crash happened faster than the price feeds could react.

Opportunistic traders noticed immediately. They bought cheap USR at $0.025 on the open market, deposited it as collateral at an oracle-believed $1, and borrowed USDC, ETH, and other real assets against it. The protocols, blind to the depeg, honored the trades. The result:

  • Fluid/Instadapp absorbed over $10 million in bad debt and saw more than $300 million in single-day outflows — its worst day on record.
  • Morpho's Gauntlet USDC Core vault lost around $6 million through its Public Allocator, which dutifully rebalanced toward pools where utilization had spiked (because arbitrageurs were borrowing against mispriced collateral).
  • Euler faced forced liquidations that compounded the price collapse, pushing USR further into the depeg death spiral.

DeFi has seen this movie before. The 2022 UST collapse, the 2023 Euler hack's bad-debt aftermath, the 2024 Prisma and Curve depeg episodes — each taught the same lesson: when a collateral asset depegs, lending markets that don't react within minutes become wealth transfer machines from honest suppliers to arbitrageurs. The Protos headline said it cleanly: "Resolv hack shows DeFi learned nothing from last contagion."

Resolv vs. Terra: Different Failure, Same Outcome​

It's tempting to lump Resolv in with Terra/LUNA. Both are stablecoins that lost their peg catastrophically. But the failure modes could not be more different, and the distinction matters for how protocols defend themselves going forward.

Terra was an internal mechanism failure. The algorithmic bonding between UST and LUNA unwound as designed once confidence broke — the system ate itself from the inside, following its own rules. There was no external attacker; the incentive structure was the bug.

Resolv was an external key compromise. The delta-neutral hedging strategy that backed USR worked correctly throughout the incident. Reserves were in place. The peg held everywhere except at the minting interface, where someone with a stolen credential was manufacturing supply out of nothing. The system didn't fail — it was overruled.

This distinction reshapes the defensive playbook. Against an algorithmic failure, you improve the mechanism: better bonding curves, circuit breakers, collateralization buffers. Against a key compromise, mechanism improvements are irrelevant. You need hardware security modules with strict usage policies, threshold signatures that require multiple parties, on-chain rate limits and mint caps that no single key can bypass, and continuous monitoring of the cloud accounts that hold privileged roles.

What Changes Next — Or Should​

The $308B+ stablecoin market is now large enough that single-protocol failures have systemic weight. The Resolv incident surfaces several changes that serious issuers and DeFi integrators will likely implement through 2026:

  • On-chain mint caps as standard. No off-chain signature should be able to mint more than a small percentage of supply in one call, regardless of who signs it. This alone would have limited the Resolv attack to single-digit-million losses.
  • Depeg circuit breakers in lending markets. Oracles that compare market price to redemption price and automatically pause borrowing when the two diverge by more than a threshold. Morpho, Euler, and Fluid have all signaled work in this direction post-incident.
  • Cloud infrastructure audits alongside smart contract audits. Firms like Halborn and Chainalysis are expanding scope to include KMS configurations, IAM reviews, and key rotation audits. Expect this to become table stakes for any protocol with privileged off-chain signers.
  • Threshold signatures and MPC for minting authority. A single KMS key controlling unlimited minting is an artifact of early DeFi. MPC-based schemes that require multiple independent parties to co-sign mint operations are now production-ready and dramatically raise the cost of an attack.
  • Separation of collateral custody from minting authority. In a well-designed system, even a fully compromised signing key cannot produce tokens that exceed verified on-chain collateral. Resolv's architecture collapsed these concerns; future designs will need to separate them.

The uncomfortable truth is that the Resolv hack is not a black-swan event. It's the predictable consequence of building billion-dollar financial primitives on top of single-key cloud signers. Every yield-bearing stablecoin with an off-chain oracle or signer has a version of the same attack surface. Some will add the controls above. Others will find out the hard way.

The Infrastructure Takeaway​

For builders, the Resolv hack reframes the security conversation. A clean Solidity audit is necessary but nowhere near sufficient. The weakest link in most modern DeFi protocols is the operational security of the cloud accounts, CI pipelines, and developer machines that hold privileged credentials. That's the layer attackers will keep targeting, because that's where the payoff is largest relative to the difficulty.

It also reframes the diligence conversation for allocators and integrators. Before accepting a new stablecoin as collateral, the relevant questions aren't just "has the code been audited" and "what's the collateral ratio." They're: Who holds the minting keys? Where are those keys stored? How many independent parties need to sign to issue new supply? What on-chain caps exist that no off-chain signer can bypass? If a protocol can't answer those questions crisply, it's not ready to be a systemic counterparty.

Seventeen minutes, one AWS key, $25 million gone, hundreds of millions in collateral damage across DeFi. The code worked exactly as designed. That's the problem.

BlockEden.xyz provides enterprise-grade blockchain infrastructure across Sui, Aptos, Ethereum, and 15+ chains, with a strong focus on secure, high-availability node and API services. If you're building stablecoin or DeFi infrastructure where operational security matters as much as code quality, explore our API marketplace to build on foundations designed to last.

Sources​

Share on Twitter