In the first three months after Ethereum’s Pectra upgrade, over 366,000 transactions leveraged EIP-7702 delegation. 63% of them were malicious. $2.36 million stolen, $10.14 million exposed. This isn’t a bug report—it’s a systemic failure of trust. The very mechanism designed to bring smart contract capabilities to externally owned accounts has become the primary vector for exploitation. And the industry is still celebrating adoption numbers.
Let me step back. EIP-7702 is the Ethereum improvement proposal that allows an EOA to temporarily delegate its code execution to an external smart contract. Think of it as a programmable proxy: your address stays the same, but the logic that runs when you sign a transaction can be swapped out. It’s the foundation for account abstraction without migration, a promise of seamless upgradeability. The USENIX 2026 security paper that exposed this data analyzed over 228 billion on-chain transactions to trace the attack patterns. The authors found that 242 malicious contracts were actively used, and 500 more were deployed via CREATE2 but never activated—a ticking time bomb.
Here’s where the technical analysis gets personal. I’ve spent years auditing DeFi protocols, and one of the bedrock assumptions has always been that msg.sender == tx.origin could serve as a check against phishing attacks. That check is now worthless. EIP-7702 breaks the deterministic relationship between the transaction originator and the code that executes. An attacker can bind a malicious contract to your address, and when you sign what looks like a benign transaction, that contract executes arbitrary logic. The delegation is invisible to the user’s wallet interface unless explicitly scanned. And the scanning tools are not keeping up.
But the deeper issue is the attack surface. The paper identified two primary attack types: protocol-related exploitation and deceptive rebinding. Protocol-related attacks target DeFi contracts that still rely on legacy security assumptions—like using tx.origin for access control. Deceptive rebinding is more insidious: an attacker convinces a user to re-delegate to a new contract that looks identical to a legitimate one, then drains the account. The 500 unactivated CREATE2 contracts are particularly concerning. They exist on-chain, waiting to be activated by their deployer. If the private key to that deployer is compromised, or if the deployer turns malicious, every address that delegated to that contract becomes vulnerable. This is a supply chain attack on the delegation layer itself.
Here’s the contrarian angle that most analysts miss: the narrative that EIP-7702 is a success because it’s being adopted is fundamentally flawed. Adoption metrics are not the same as security metrics. 63% malicious usage means the feature is being exploited more than it’s being used legitimately. The industry is celebrating a feature that is primarily a weapon. The bull market euphoria masks this. Investors see the transaction volume and think “network effect,” while attackers see the same volume and think “attack surface.” The delegation model introduces a new class of authorized malware—code that runs with your permission, but not your consent.
The solution is not more code audits. Audits check for bugs in the implementation, but they cannot check for malicious intent in the delegation contract. The only path forward is a fundamental rethinking of trust. We need delegation whitelists—curated lists of approved contracts that wallets enforce. We need hardware-backed signatures that verify the delegation code before it’s executed. We need a new consensus on what security means in a world where your address can be hijacked without losing your private key. As I’ve written before, “True ownership begins where the server ends.” But here, the server is the delegation code. If that code is malicious, your ownership is an illusion.
Debate is the compiler for better consensus. The industry must debate whether EIP-7702 in its current form is worth the risk. The USENIX paper shows that the attack vector is real, immediate, and growing. The 366,000 transactions are just the beginning. The next wave will target the 500 dormant contracts. The next wave will target wallets that don’t verify delegation code. The next wave will target DeFi protocols that haven’t updated their tx.origin checks. And the market will react—not with a crash, but with a slow erosion of trust in the account abstraction narrative.
The takeaway is not to abandon EIP-7702. It’s to recognize that we have a security gap that needs to be closed before the feature becomes standard. The Pectra upgrade was a technical achievement, but it was also a security regression. The next upgrade must include a mandatory delegation verification layer. Until then, every EOA is a potential liability. And every user who signs a transaction without checking the delegation code is playing Russian roulette with their assets. The future of account abstraction depends on fixing this trust model. Either we implement the safeguards, or we accept that the upgrade we celebrated is the one that broke the security model we relied on.
I’ve seen this pattern before: a powerful feature gets released, adoption explodes, and then the attacks catch up. The difference this time is that the attacks are already ahead. 63% malicious usage is not a bug—it’s a systemic failure. We need to fix it before the next 366,000 transactions happen.
