The Kelp DAO Hack Wasn't a Smart Contract Exploit. It Was an RPC Infrastructure Attack.

On April 18th, $292 million was drained from Kelp DAO's bridge in 46 minutes. Every post-mortem you've read focused on the 1-of-1 DVN configuration on LayerZero. That's the right conversation — but it's not where the attack actually executed.

The smart contract worked exactly as written. No reentrancy. No key compromise. The code wasn't the vulnerability. The infrastructure feeding data to the code was.

What Actually Happened at the Infrastructure Layer

Here's the attack sequence:

1. Lazarus Group (TraderTraitor unit) identified that Kelp DAO's bridge used a single LayerZero DVN verifier
2. They compromised two RPC nodes that the DVN used for transaction verification
3. They launched a DDoS against the remaining clean nodes — forcing the system to rely exclusively on the compromised ones
4. The single verifier received corrupted state data and confirmed a fraudulent cross-chain transaction as legitimate
5. 116,500 rsETH (~$292M) was released from escrow to the attacker's address
6. The malicious binary self-destructed, wiping logs and traces
7. Kelp paused contracts 46 minutes later — blocking two additional attempts worth ~$100M

The result: Aave froze rsETH markets with $230M in potential bad debt at risk. rsETH, deployed across 20+ chains, was suddenly undercollateralized everywhere simultaneously.

Why This Is a Different Threat Model

Most security audits cover:

• Reentrancy attacks
• Flash loan manipulation
• Oracle price manipulation
• Access control vulnerabilities

Very few cover what happens when the RPC layer is compromised or degraded under load.

This is the gap the Kelp exploit exposed. Your smart contract can be perfectly written and still execute malicious transactions — if the data it's acting on comes from a compromised source.

The LayerZero vs Kelp Blame War

Both parties made public statements. Both are partially correct.

LayerZero's position: Kelp used a 1-of-1 DVN configuration against explicit warnings going back to July 2024. Their protocol wasn't broken — Kelp's configuration was.

Kelp's position: 1-of-1 DVN is the default configuration in LayerZero's quickstart guide. Approximately 40% of protocols on LayerZero use the same setup. The RPC nodes that were compromised were LayerZero's own infrastructure, not Kelp's.

Both statements can be true simultaneously. And that's exactly what makes this dangerous: a default configuration, trusted by most, with a single point of failure at the infrastructure layer.

The Arbitrum Governance Precedent

Four days after the exploit, Arbitrum Security Council executed an emergency vote: 9 of 12 multisig signers froze 30,766 ETH (~$71M) at the attacker's address.

This is important for two reasons.

First, it's a win for victims — roughly 25% of stolen funds are now locked and potentially recoverable.

Second, it's a proof point that "permissionless" is not an absolute state. A group of 12 people, through a governance mechanism, can freeze funds on a "decentralized" network. When you're designing systems, this is a centralized choke point that exists whether you acknowledge it or not.

Four Infrastructure-Level Lessons

1. Never use 1-of-1 verification on a bridge

// Dangerous - single point of failure
DVN config: {
  requiredDVNs: ["single-dvn-address"],
  optionalDVNs: [],
  optionalDVNThreshold: 0
}

// Correct - multiple independent verifiers required
DVN config: {
  requiredDVNs: ["dvn-address-1", "dvn-address-2"],
  optionalDVNs: ["dvn-address-3"],
  optionalDVNThreshold: 1
}

One verifier = one attack vector. Multi-DVN with independent providers is the minimum viable security posture for any bridge holding meaningful value.

2. Your RPC nodes are part of your threat model

The question isn't just "is my endpoint up?" — it's "is my endpoint returning accurate state?"

These are different questions with different answers. A compromised node can be fully available while returning fabricated data. Standard uptime monitoring won't catch this.

For cross-chain verification specifically:

• Use multiple independent RPC sources from different providers
• Implement response consistency checks across sources
• Treat RPC endpoint selection as a security decision, not just an infrastructure decision

3. Default configurations can be dangerous

If you're copying a protocol's quickstart guide, check whether it's optimized for simplicity rather than security. These are different optimization targets.

Before deploying any bridge configuration to production:

• Read the security documentation, not just the getting-started guide
• Check what the recommended production configuration looks like vs the default
• Understand what each parameter controls and what failure mode it protects against

4. Shared public nodes amplify attack surface

The Kelp exploit targeted specific RPC nodes. But the broader risk applies to any application using shared public endpoints for security-critical operations.

Shared nodes aggregate traffic from thousands of applications. A DDoS targeting one application on a shared endpoint degrades service for all of them. For most dApps, this means slower response times. For a bridge DVN, it can mean routing verification traffic to compromised fallback nodes.

What to Audit in Your Stack Today

If you're running a bridge or cross-chain application:

Checklist:
□ How many independent DVN verifiers are required for message validation?
□ Are those verifiers using independent RPC sources?
□ What happens to your verification logic if one RPC source goes down?
□ What happens if one RPC source returns stale or incorrect data?
□ Are any verification-critical RPC calls going through shared public endpoints?
□ Does your governance design have emergency intervention mechanisms?
   If yes — are you treating those as features or risks?

The Kelp post-mortem will focus on DVN configuration. That's correct. But the RPC layer is where this attack was actually executed — and most teams still aren't modeling that threat.

GetBlock provides dedicated and shared RPC nodes across 130+ blockchains including Ethereum, Arbitrum, and TON. If the Kelp story made you think about your own RPC setup — explore our infrastructure.