The first hard signal was not a price chart. It was a transaction log. Across roughly 1.5 million EIP-7702 authorization events, the audit dataset recovered only 629,407 unique authorized accounts and 242 confirmed malicious contract targets. Then, in just three months after activation, more than 3.66 million delegation transactions hit mainnet, and about 63% of them routed value or permissions toward known malicious behavior. The direct loss recorded in the study was only about $2.36 million. That number is small. The meaning of it is not.
This is what happens when a protocol upgrade is technically correct and behaviorally premature. EIP-7702 succeeded at its core job: it gave externally owned accounts, the plain address every user has held since Ethereum began, the ability to delegate to smart-contract logic without forcing a wallet migration. That is a real architectural improvement. But the audit also shows a sharper truth. The protocol changed what an EOA can become, while most of the ecosystem still assumed what an EOA always was. That mismatch is now the dominant security problem, not a hypothetical one.
The upgrade in question is part of Ethereum’s Pectra hard fork, activated on May 7, 2025. Before EIP-7702, account abstraction existed mostly through ERC-4337, a separate system that let smart accounts exist alongside EOAs. That approach was modular and cautious. It added new behavior without rewriting the original semantics of a user address. EIP-7702 chose the opposite route. It changed the base model directly. An EOA can now temporarily behave like a smart contract by delegating execution to authorized code. The address stays the same. The permissions do not.
This is a significant distinction. ERC-4337 was a wrapper around EOAs. EIP-7702 is a mutation of EOA behavior. It is more elegant, more gas-efficient, and more dangerous than the prior path. The advantage is obvious: users do not need to abandon familiar wallets, move funds to new account types, or accept a broken UX just to get account-abstraction features. The risk is also obvious. A plain address can now sign an authorization that grants another contract access to it. If the wallet UI, the signing flow, or the downstream contract set is weak, that authorization becomes a new primitive for theft.
The security thesis behind EIP-7702 is not naive. It does not claim to remove private-key risk. It claims to reduce it by decoupling the signing key from static ownership semantics. Under a traditional EOA, control over the private key equals full control over the account. Under EIP-7702, that remains true in a limited sense, but the account can also delegate authority to code. That is a different trust model. The old model was simple and brittle. The new model is flexible and conditional. The vulnerability is in the conditional layer.
The audit found the clearest evidence of that failure in one of the most familiar EVM assumptions: msg.sender == tx.origin. Old contracts used this check as a crude anti-phishing rule. It worked because an EOA could not send a transaction through arbitrary contract logic. Once EIP-7702 enables delegation, that assumption breaks. A delegated account can trigger contract calls in a way that invalidates the old mental model of sender identity. The attacker does not need to steal a private key first. The attacker only needs the user to approve a delegation that later points toward malicious logic.
The dataset makes this concrete. The audit team collected data from May 7, 2025, through May 31, 2026, across all EVM chains that support EIP-7702. They used historical data and cross-chain tracking to normalize duplicate authorizations from bridge-like transfers, leaving a cleaner view of actual on-chain activity. From that view, only 14,173 transactions were linked to confirmed losses, but 49,392 were tagged as malicious. The distinction matters. Some attacks do not immediately drain funds. They prepare future drainage, create spoofed states, or install logic that appears safe until a later trigger fires.
The most common successful theft pattern was direct authorization. A user signs an EIP-7702 authorization for a malicious contract. The contract then calls an approval or transfer function inside the account’s own context. That bypasses the older assumption that delegated calls cannot perform privileged account actions. In a normal ERC-20 flow, the wallet would ask the user to approve a spender. In the EIP-7702 path, the malicious contract can sometimes perform that approval itself after the delegation is live. This is not a clever UI trick alone. It is a protocol-level permission escalation.
The second pattern is reauthorization. This is where the attack becomes harder to detect. A user authorizes what appears to be a benign contract. Later, that contract changes its delegated mapping to a malicious target. The audit observed more than 1,100 such reauthorization events. The malicious target set behind them included contracts such as 0x3d22, 0x92d9, and 0xf2b8, among others. This is important because it defeats the common mitigation story. Users and wallet teams often assume that if the first contract looked harmless, the risk was limited. It was not. The delegation layer is mutable, and the audit found that this mutability was already being exploited at scale.
The third pattern is malicious self-creation. A wallet or dApp creates a contract with CREATE2, then immediately authorizes it. The audit found 500 events of this kind. These are suspicious because they combine contract deployment and permission grant in one compact flow. The attacker does not need a well-known token, a trusted interface, or a long social-media runway. The code can be generated on the fly, linked to the user’s account, and executed before the user understands what happened. This is closer to exploit engineering than to ordinary phishing.
Taken together, these patterns show that the protocol is not merely under attack. It is being tested by actors who have already mapped the weak points. The study identified 1,014 exposed contracts and 213,557 exposed tokens. Many of the target tokens were familiar assets such as WETH, USDT, USDC, TUSD, and various yield or bridge tokens. This is not an edge case inside an exotic memecoin market. It is an attack surface that touches the standard liquidity the network depends on.
The hidden cost is worse than the loss number. The audit found that 24% of the affected ETH or ERC-20 balances became trapped. That is not the same as stolen. It means funds were locked, frozen, or otherwise rendered unusable after bad authorizations, reauthorizations, or protocol failures. For a user, a trapped balance can be functionally equivalent to a drained wallet. For the ecosystem, it introduces a new failure mode. EIP-7702 can break account liquidity without always producing a clean theft event that is easy to report, classify, or reverse.
This is the part most market narratives miss. The direct loss of $2.36 million is small enough that a trader might dismiss the story. The trapped-value figure is not. It changes the nature of the problem from a fraud report into an infrastructure incident. Wallet providers, bridge teams, DeFi protocols, and RPC operators are now dealing with a permission layer that can freeze or redirect value inside existing EOAs. That is a broader blast radius than another phishing campaign against a vulnerable wallet UI.
From a technical standpoint, EIP-7702 remains a successful design. It solved a real problem. Account abstraction had been delayed for years because wallets, developers, and users could not agree on a low-friction migration path. ERC-4337 preserved compatibility but required a separate system. Native smart accounts require new addresses and new UX. EIP-7702 avoided both pain points by letting users keep their original address. It also kept the protocol closer to Ethereum’s existing architecture instead of pushing account logic into a peripheral subsystem.
The tradeoff is clear. Compatibility reduced migration friction while increasing the ambiguity of what users were actually signing. This is exactly the sort of tradeoff that looks clean in a paper and messy in production. In research, the protocol can be described as reversible and temporary. In practice, users approve delegation flows, reauthorize contracts, or interact with front ends that obscure the mapping between their key, their address, and the code receiving authority.
The study also reveals a governance problem. The Ethereum Foundation and major wallet teams issued guidelines after the incidents. EIP-7702 itself was not rolled back. Instead, the ecosystem tried to patch around it through UI warnings, contract reputation lists, and improved signing disclosures. That response is understandable. The upgrade is already live. But it also exposes a deeper issue. The protocol introduced a new account capability faster than the industry could build consistent defenses around it.
The audit’s most important warning was not that EIP-7702 should be abandoned. It was that the ecosystem’s older security primitives should be considered obsolete once EIP-7702 is active. Contracts still relying on msg.sender == tx.origin are not merely outdated. They are structurally unsafe. Wallets that show users only the final contract address are insufficient. Security teams that treat authorization events as ordinary transaction metadata are missing the point. The delegated layer needs its own policy model, its own monitoring, and its own user-facing language.
One of the more striking numbers in the report is the scale of adoption itself. More than 3.66 million delegation transactions in three months is not slow uptake. It is fast uptake. The protocol was being used before defensive tooling had caught up. This is not a failure of cryptography. It is a failure of coordination. The network added a new capability; the surrounding stack treated it like a minor UI change.
The reauthorization issue deserves special attention because it undermines the simplest mitigation. A wallet can warn users before the first authorization. It can also maintain a blacklist of known malicious contracts. But if a benign-looking contract later rebinds to a malicious target, the original warning becomes stale. The user already approved the path. The UI already moved on. The malicious behavior arrives through a change that the wallet may not see as a new signing event.
This creates a paradox for wallet teams. They need to monitor not only the contract the user approved, but also the future behavior of that contract. They need to track whether the authorized mapping changes. They need to consider whether the contract’s code is stable or whether it can rewrite its own delegated authority. That turns a signing action into a continuous risk. The user does not sign once and finish. The user signs once and remains exposed until the delegation is revoked or the contract is proven stable.
The self-created contract pattern adds another layer of uncertainty. CREATE2 authorizations make it harder to apply reputation checks before the signing event because the contract may not have a useful history. The deployment itself becomes part of the exploit. This is why the audit’s 500-event cluster matters. It is not the largest category, but it is the most protocol-native. It shows attackers using the new feature as an attack surface rather than merely pointing users toward a malicious token front end.
The trapped-token issue also has implications beyond individual victims. If 24% of affected balances are unusable after bad authorizations, then recovery teams and support systems need new workflows. The old flow for phishing was relatively simple: identify the malicious address, block it, report the transaction, advise the user. The EIP-7702 flow is more complex. The malicious contract may be only one step in a chain. The delegated mapping may change. The victim’s address may still appear valid while its permissions are already compromised.
The study’s use of historical and cross-chain data is useful here. EIP-7702 is not a single-chain story. The audit normalized duplicate authorizations across chains, which reduced noise from bridge-like transfers and made the malicious patterns easier to see. That matters because attackers can move permissions, contracts, and users across ecosystems. A wallet that treats each chain as an isolated incident will miss the larger delegation graph.
The security implications for DeFi are direct. Any protocol that still relies on old EOA assumptions needs a re-audit. The report explicitly calls out msg.sender == tx.origin checks as vulnerable. If a lending, bridge, or routing contract still assumes that sender equality implies account control, it is now operating on stale logic. This is not theoretical. The audit already found active exploitation paths.
The wallet implications are even more direct. A wallet UI cannot ask the user to approve a raw delegation and hope that the user understands it. The UI must disclose what the delegated contract can do, whether it can reauthorize, whether it can approve tokens on the user’s behalf, and whether the authorization can be revoked cleanly. It must also show whether the contract is newly created, whether it has a history, and whether it is already known as malicious. None of this is optional if EIP-7702 is going to remain part of Ethereum’s core account model.
The audit’s conclusion that 63% of delegation transactions were malicious is alarming, but it should not be misread. That percentage does not mean 63% of users were drained. It means the protocol’s adoption curve crossed the attacker frontier almost immediately. The attackers did not wait for slow institutional uptake. They targeted the feature as soon as it became useful. In that sense, EIP-7702 was not merely launched. It was captured into an adversarial usage pattern within weeks.
This also explains why the market reaction may remain muted even as the technical risk remains high. A $2.36 million loss is too small to move a major asset by itself. But a protocol-level security story does not need to produce a large immediate loss to affect confidence. It needs to show that ordinary users can authorize bad behavior through a supported upgrade. That is enough to force wallet teams, exchanges, bridges, and DeFi apps into defensive redesign.
The strongest mitigation is not a slogan. It is a whitelist model for delegation. Users should authorize only known, stable, reviewed contracts. Wallets should treat first-time or newly created delegation targets as high risk. Protocols should avoid assuming that delegated calls cannot perform privileged account actions. Auditors should treat EIP-7702 compatibility as a separate security section, not a footnote in a normal smart-contract review.
There is also a product-design lesson. Account abstraction is not complete when code works. It is complete when users can understand what they are signing and revoke what they signed without becoming dependent on expert tooling. EIP-7702 improved the first part. It left the second part underdeveloped. The current incidents are the price of that gap.
The contrarian point is this: the market may punish EIP-7702 too little. The losses are small enough to ignore. The adoption is high enough to normalize. But the real failure is structural. Ethereum has expanded what an EOA can do while the surrounding security assumptions still describe an older EOA. That mismatch will not disappear because the protocol is mature. It will persist until wallets, contracts, and audits all stop treating delegated EOAs as ordinary accounts.
The forecast is not that EIP-7702 will fail. It is too embedded now for that. The forecast is that the next major incident will not look like a classic drain. It will look like a silent authorization change, a trapped balance, or a delegated contract that behaves normally for weeks before reauthorizing to a malicious target. That is a slower attack. It is also harder to detect.
Based on my audit experience, the useful question is not whether EIP-7702 is a good upgrade. It is. The useful question is whether the ecosystem is ready to defend a delegated EOA without pretending it is still the same object it was before. Right now, the answer is no. The protocol advanced. The security model did not. That is the vulnerability that will define the next phase of Ethereum’s account-abstraction story.
