Over the past three months, 3.66 million EIP-7702 delegations were executed on Ethereum mainnet. 63% of them were malicious. That’s not a typo—it’s a signal. The Pectra upgrade, activated May 7, 2025, was supposed to be the gentle bridge between the old EOA world and the programmable future. Instead, it became a honeypot for attackers, and the data from a new USENIX 2026 study reveals exactly how the architecture’s promise inverted into its peril.
Tracing the sentiment pivot from 2017 to today, I recall sitting in a Taipei coworking space in 2017, auditing 400+ whitepapers from the ICO boom. Back then, the narrative was “code is law.” We believed that if you controlled the private key, you controlled the asset. The EOA was a fortress. But Ethereum’s account abstraction journey began with a simple question: what if an EOA could behave like a smart contract without losing its identity? EIP-7702 answers that by allowing an EOA to delegate its logic to a contract code—temporarily, revocably, but with full execution rights. The address stays the same, the balance stays, but the behavior changes. It’s elegant. It’s also a Trojan horse.
Context: The Pectra upgrade introduced EIP-7702 as a soft fork, not a hard break. It lets users sign a delegation that attaches code to their address. For a single transaction, the address acts like a smart contract wallet. The user can revert at any time. In theory, this removes the friction of migrating to a new smart wallet address. In practice, it creates a new attack surface: the delegation itself. The USENIX team, analyzing 228 billion historical transactions, scraped the entire on-chain record of EIP-7702 usage from May 2025 to August 2025. They found 3.66 million delegation transactions, but 63% were initiated by malicious contracts. The attack vector is not code injection—it’s social engineering with a twist: attackers trick users into signing a delegation that gives control to a contract that then drains assets. The twist is that the delegation can be re-bound to a different contract later, undetected, because the wallet UI sees the original delegation as benign. The code is not the exploit; the trust in the signature is.
Core: The mechanism of EIP-7702 is deceptively simple. A user signs an authorization message that maps their address to a contract address. The contract then executes on behalf of the user. The user retains the private key, so they can revoke at any time. But here’s the flaw: the revocation is also a signature. If the user signs a new delegation, the old one is overwritten. Attackers craft phishing flows that get the user to sign a delegation that looks like a legitimate transaction—say, a token approval for a DEX—but the delegated contract is actually a drainer. The study catalogs 242 unique malicious contracts, 500 of which were deployed via CREATE2 (so they don’t exist until deployed, and can be deployed at a predictable address later). The most insidious technique: “delegation re-binding.” An attacker creates a benign contract, gets the user to delegate to it, then later swaps the code at that address via CREATE2 to a malicious version. The wallet UI, which checks the delegation address, sees the original benign contract and flags no risk. Meanwhile, the user’s assets are being siphoned. The total tangible loss identified is $2.36 million, but the study flags $10.14 million in exposed assets at risk. And that’s just from the transactions they could trace. Based on my audit experience—I spent 2020 reverse-engineering Compound and Aave’s lending mechanics—I can tell you that the real number is likely higher, because many victims don’t report. The DeFi composability critique I wrote during that summer warned about the fragility of synthetic collateral. The same fragility applies here: the composability of EIP-7702 with existing DeFi contracts creates a systemic risk. The old msg.sender == tx.origin check, which many protocols used to prevent phishing, no longer works. The delegated contract can call any protocol, and the tx.origin is still the original EOA, but the msg.sender is the delegate. So protocols that relied on that check are now vulnerable. Mapping the cultural resonance behind the NFT boom, I saw how community utility narratives drove value. Here, the narrative of “seamless upgrade” drove adoption, but the security culture didn’t keep up. The protocol’s own white paper—the EIP—was peer-reviewed, but the implementation’s safety was not stress-tested against real-world phishing.
Contrarian: The default narrative is that EIP-7702 is an upgrade, and that the security issues are growing pains that will be fixed with better wallets and user education. I disagree. The crisis is structural. The very premise of EIP-7702—that an EOA can delegate code without migrating—requires the user to verify the code they are delegating to. That’s impossible for 99% of users. The industry’s solution is “whitelist” or “allowlist” of approved contracts, but that centralizes control and defeats the purpose of permissionless innovation. The contrarian angle: EIP-7702, as currently designed, is a net negative for security because it breaks the simplicity of the EOA model without providing a safety net. The optimistic rollup analogy fits: we thought ZK rollups would solve everything, but the proving costs are absurdly high. Similarly, we thought account abstraction would solve the user experience, but it introduced a new class of phishing that is harder to detect. The Ethereum community is now in a race to build “delegation firewalls” or “zero-trust authorization” layers. But that’s a patch, not a fix. The real blind spot is that the industry prioritized adoption over safety. The USENIX study shows that within three months of activation, attackers had already automated malicious delegations. The defensive measures—wallet warnings, contract audits, user education—are reactive. The attackers are operating at the speed of code, while the defenders are still discussing standards. Following the code trail from hack to recovery, I’ve seen the same pattern: the faster the feature, the faster the exploit. The ICO sentiment pivot taught me that hype-outpaces-reality gaps are always exposed by data. The 63% malicious rate is the data. The market should be pricing in a risk premium for Ethereum’s account abstraction stack. But the price of ETH hasn’t moved significantly. That’s because the market is still in denial, or because the losses are still small relative to total value locked. But the narrative is already breaking. On Twitter, I see the FUD starting. The sentiment is shifting from “EIP-7702 is the future” to “EIP-7702 is dangerous.” That’s a pivot point. The bear market context matters: survival matters more than gains. Readers want to know if their assets are safe. The answer is: not if you use EIP-7702 without extreme caution.
Takeaway: The next narrative pivot is not about whether EIP-7702 will be adopted—it already is. The next narrative is about the security infrastructure that must be built around it. The winners will be the wallet providers who implement delegate whitelisting, the security firms that offer real-time delegation monitoring, and the protocols that update their tx.origin checks. The losers will be the users who blindly sign delegation transactions. The algorithmic truth behind the token narrative is that the token itself—ETH—is not at risk, but the trust in the network’s ability to safely evolve is. Rewriting the ledger of crypto’s lost legends, I see a pattern: every innovation that simplified the user interface at the cost of security eventually caused a crash. The 2017 ICOs, the 2020 DeFi composability, the 2021 NFT cultural boom—all had a moment where the security architecture cracked. EIP-7702 is that moment for account abstraction. The question is not whether the code is secure; it’s whether the human layer can keep up with the speed of the code. The answer, so far, is no. The next six months will determine whether Ethereum can fix this before the next bull cycle amplifies the damage. If not, we’ll be tracing the code trail from hack to recovery for years to come.