EIP-7702's First Three Months: 63% Malicious Delegations and the Death of tx.origin Defense

Within 91 days of Pectra going live, Ethereum processed 3.66 million EIP-7702 authorization transactions. Nearly 63 percent of them were malicious. That is not an adoption curve. It is a threat surface. The feature was supposed to make account abstraction less complicated. Instead, it exposed how fast attackers can weaponize a mainstream protocol upgrade before wallet vendors ship matching defenses. EIP-7702 changes the base meaning of an externally owned account. Under ERC-4337, smart account functionality was layered into a secondary system. Under EIP-7702, an EOA can keep its original address, remain compatible with existing infrastructure, and delegate its execution to smart contract code. This is a paradigm shift, not an incremental patch. It gives ordinary wallet addresses programmability while preserving address stability. In theory, that means users can upgrade wallets without moving assets, bridges, or approvals. In practice, delegation creates a new authorization boundary between the private key and whatever code is attached to it. The key remains a key. It is no longer the only thing that controls the account. Delegated code now also holds account-level authority, which rewrites the trust model that many contracts, RPC tools, wallet extensions, and DeFi risk systems were built on. The current analysis comes from a USENIX security paper that processed 22.8 billion historical transactions. The research team identified a clear pattern: EIP-7702 was adopted quickly, but the security assumptions around it were not updated at the same speed. Ethereum activated the upgrade on May 7, 2025. The report then tracked the first three months of usage and found 3.66 million authorization transactions. More than half were malicious. That statistic is hard to dismiss. It means the first major wave of native account abstraction was also a large-scale attack surface, not a controlled rollout of safer wallets. The paper documented 242 malicious contracts used in the attacks. It also flagged roughly 500 CREATE2 contracts that appear designed to stay undeployed until a later time. In other words, some malicious infrastructure was built to wait. It did not need to trigger immediately. From a pure execution perspective, the rollout was technically successful. The mainnet accepted the new transaction type, wallets began integrating it, and asset movements continued. But the security model did not mature at the same pace. The research found that malicious rebinding is a core attack style. A wallet may first delegate its code to a benign contract. Later, that contract rebinds the account to another delegated address, often a malicious one. The user sees the same wallet, the same address, and the same token balances. The execution logic underneath has changed without a visible UI mismatch. This is the part that breaks traditional wallet trust. Most wallet interfaces verify the address, not the entire delegation chain. During my audit work, I was trained to treat state transitions as the source of truth. Addresses are identifiers. Code is authority. If a UI only displays the identifier while authority is silently handed to another contract, the displayed state is already stale. The hash is not lying. The logic path is hiding. DeFi contracts face an even larger problem. Many protocols still use checks like msg.sender == tx.origin to block phishing attacks. EIP-7702 undermines that assumption because a wallet can now execute through delegated code while tx.origin points to the original EOA. The old check no longer proves the initiating actor is a human using a simple wallet. It may be delegating execution to a malicious or maliciously rebound contract. The research explicitly identifies this as a critical vulnerability class. Legacy DeFi defenses that relied on tx.origin are no longer reliable. A user can be tricked into signing one delegation transaction, and the delegated code can then perform operations that old wallets would have treated as impossible for an EOA. The attack patterns are also different from ordinary private-key leaks. In a private-key compromise, the attacker gains full signing power. With EIP-7702 abuse, the private key may remain with the user. What is lost is the exclusivity of that key. The delegated code receives account permission, effectively creating a second authority. That asymmetry did not exist in traditional EOAs. It also explains why some wallets look normal after an attack: the signing key was never moved, only the code path was replaced. The report separates two major categories of malicious behavior. The first is protocol-related delegation, where attackers bind assets to contracts that attempt to drain them through standard transaction flows. The second is deceptive rebinding, where a previously trusted or neutral contract changes its delegation target after the user has already accepted it. The second category is more dangerous because it defeats the mental model of set-and-forget wallet upgrades. There is also an operational dimension. Many of the malicious delegations appear automated. They cluster around predictable phishing scripts rather than custom exploitation. That raises an uncomfortable point: the barrier to attack was not high. Attackers did not need sophisticated infrastructure. They needed enough delegation activity to funnel assets into malicious code before wallets or security tools recognized the pattern. The financial exposure matters, but it is not the main signal. The report identified roughly $12.5 million in aggregate exposure across the flagged attack classes. That is small for a global Ethereum narrative, and it is not the reason this should command attention. The real signal is the ratio: 63 percent malicious usage in the first three months of a major protocol feature. When the code bleeds, only the ledger survives. That is not a rhetorical line. It is a practical instruction for auditors, wallet engineers, and DeFi teams. The ledger can show exactly which addresses interacted with which delegated contracts. The problem is that most users do not read ledger state before signing. They read a wallet UI. The study is especially valuable because it is based on verified transaction data, not speculation. The research team extracted millions of real EIP-7702 events from Ethereum. It cross-referenced those events with known malicious contracts and traced the resulting asset flows. This is the kind of forensic baseline that should have existed before the upgrade reached broad wallet support. Now it exists after the attacks, which means the security community is catching up to an already deployed attack vector. I do not trust whispers; I trust verified hashes. The paper follows that rule. The 22.8 billion transaction sample is broad enough to distinguish normal adoption from automated abuse. It also exposes a gap between protocol-level capability and product-level defense. EIP-7702 was designed to make wallet migration unnecessary. It succeeded. But it also made wallet migration look safer than it was. Users were encouraged to think of delegation as a one-time technical action. The research shows delegation is a persistent risk surface, especially when the delegated contract can rebind. The counterintuitive conclusion is that EIP-7702 may make traditional EOA security worse before it makes smart wallets safer. The feature narrows the migration cost to zero, but it widens the authorization attack surface. That is not a reason to abandon it. It is a reason to treat delegation as a first-class security control, not as a convenience flag buried inside a wallet settings page. A practical response starts with whitelisting. Wallets should not permit arbitrary delegation by default. The safest path is a curated list of known, audited implementation contracts. Users should be able to see exactly which code their address is executing, not just which contract address was signed. The UI must distinguish between a delegated contract and an unaltered EOA. The current research shows that false positives in security scanners are unavoidable, but false negatives are worse. A wallet that displays normal while the execution path is malicious is a failed control. DeFi protocols must also re-audit legacy assumptions. Any contract that uses tx.origin or assumes an EOA cannot contain smart contract logic needs to be updated. The safe fix is explicit verification: check the delegated contract, check the implementation address, or restrict high-risk calls to known wallet factories. Lazy capital cannot hide behind old assumptions forever. Migrations are just purgatory for lazy capital, but the alternative is worse: a protocol that remains technically active while relying on a broken defensive model. The research also raises a monitoring opportunity. Security providers can build delegation control as a service: watch rebinding events, identify newly delegated contracts, compare them against known malicious sets, and alert users before the next automated drain. This is not abstract. The data is already available on-chain. The missing piece is productization. On a market level, this should be classified as a short-term negative but a long-term neutral event. It does not prove Ethereum is fundamentally broken. It proves that the first implementation wave was premature from a security perspective. There will likely be an uptick in wallet vendor changes, security audit demand, and on-chain monitoring adoption. The token price impact for ETH is probably limited because the aggregate exposure is small and the attack pattern is not an Ethereum layer failure. The broader concern is reflexive: every high-profile account abstraction exploit reinforces the idea that smart accounts require more trust, not less. In the next version of the specification, the community should require delegation metadata. The protocol needs a standard way for wallets and DeFi protocols to read the current delegated target, verify its provenance, and compare it with prior state. The raw transaction data is already there. The market needs a reliable abstraction layer that makes this information impossible to ignore. The paper does not end the account abstraction debate. It sharpens it. EIP-7702 is not a dangerous idea. It is a powerful tool deployed before its controls were ready. The next six months will determine whether wallet vendors treat delegation as infrastructure or as an opt-in experiment. If they choose infrastructure, the 63 percent malicious rate will fall as detection improves. If they choose convenience, the next report will show a larger dollar figure attached to the same pattern. Yield is the shadow cast by risk taken. The same logic applies to wallet upgrades. The promise of reducing migration cost is real, but risk does not disappear because an address stays fixed. It moves from migration friction to delegated code. The safer design is not to eliminate account abstraction. It is to make delegation auditable, reversible, and visible to the person holding the private key. The real lesson from 3.66 million transactions is not about technical feasibility. It is about asymmetric speed. Attackers understood the new code path faster than wallets understood their own UI. The ledger captured every step. The question is whether the next wallet update will be built from that verified history or from another optimistic assumption. Forward-looking products should treat malicious delegation as a default threat model. Every wallet update should include a delegation inspector, every protocol should verify the source of call execution, and every security tool should index rebinding events as critical state changes. Ethereum has already moved past the point where account abstraction was optional. The only defensible move is to make the delegation layer as transparent as the token transfer layer. Chaos is just data waiting for a ledger. This time the ledger already exists. The attacks are on it, the malicious contracts are on it, and the rebinding events are on it. The next innovation is not another EIP. It is a security layer that forces users, wallets, and protocols to look at that data before they act.