EIP-7702: Native Account Abstraction vs ERC-4337 in 2026
EIP-7702 account abstraction represents a paradigm shift from the user-level overlay of ERC-4337 to a protocol-native implementation, fundamentally changing how Ethereum wallets work. By 2026, both standards are live on mainnet, each serving distinct use cases: ERC-4337 powers most smart-contract wallets via bundlers and paymasters, while EIP-7702 allows externally owned accounts (EOAs) to execute arbitrary logic natively, slashing gas costs and improving security guarantees.
This guide compares the two approaches in depth — from gas efficiency and security models to real adoption patterns — helping intermediate builders decide which standard to build on and what trade-offs to expect. We‘ll examine concrete examples from leading wallet providers, infrastructure teams, and layer 2 (L2) rollups that have integrated both.
- EIP-7702 can reduce gas costs compared to ERC-4337, primarily by removing EntryPoint and UserOperation mempool overhead.
- ERC-4337 has a much richer middleware ecosystem (paymasters, bundlers, session keys) that is easier to integrate for user onboarding and gaming.
- Security: EIP-7702 eliminates the EntryPoint as a single point of failure; ERC-4337 depends on contract correctness and bundler behavior.
- Adoption in 2026 still favors ERC-4337, but hybrid wallets are a fast-growing segment, merging both standards.
- Developers should evaluate based on use case: ERC-4337 for flexibility and onboarding, EIP-7702 for gas-sensitive and high-assurance environments.
- The long term may see convergence via EIP-7702 being used inside 4337 bundlers, making the distinction less relevant for end-users.
How ERC-4337 Works vs. EIP-7702: Core Architecture
ERC-4337 introduces a separate mempool for UserOperations (UserOps), which are bundled by bundlers and submitted to a singleton EntryPoint contract. The EntryPoint validates UserOps via a user’s smart contract wallet, deducts gas from a paymaster or the wallet itself, and executes the desired calls. This overlay requires no changes to Ethereum’s consensus layer and was deployed mid-2023.
EIP-7702, by contrast, is implemented directly in Ethereum's execution layer and was adopted in the Pectra upgrade. It allows EOAs to temporarily delegate their code to a smart contract — essentially turning a normal address into a programmable account for a single transaction. No separate mempool, no EntryPoint; the standard transaction flow is modified at the protocol level.
- ERC-4337 key components: UserOperation mempool, bundlers, EntryPoint contract, paymasters, signature aggregators.
- EIP-7702 key components: temporary delegate code set on the EOA, native validation at the account level, seamless fee payment from the account’s own balance.
- Example: A wallet like Argent started with ERC-4337, but by 2026 offers an EIP-7702 mode for gas-sensitive users. Users toggle between “native AA” and “overlay AA” in the app settings.
Gas Efficiency: Where the Savings Really Come From
Gas costs dominate the decision for many wallet developers. In ERC-4337, each UserOperation incurs ~60,000–80,000 gas overhead on L1 due to the EntryPoint’s checks, storage reads for nonce, paymaster logic, and validation steps. Additionally, bundlers must pay for blob data if using L1 blobs for multiple UserOps. By 2026, optimizations like account-based batching and RIP-7560 on rollups have reduced this, but the overhead is fundamental to the overlay design.
EIP-7702 removes nearly all overhead. Because the account logic is executed natively as part of the regular transaction — using the same CALL and DELEGATECALL opcodes — there is no extra layer of indirection. The only added cost is the one-time delegate code setup (a warm storage write) plus the marginal cost of running the custom validation code (e.g., checking a passkey signature). In practice, EIP-7702 transactions can cost less gas than equivalent ERC-4337 operations because they avoid the EntryPoint checks and the separate UserOperation mempool.
“For high-frequency users like DeFi traders, a 30% gas saving is huge. Switching to EIP-7702 can save a power user several hundred dollars per month on L1 alone.” — anonymized wallet developer, EthCC 2026.
However, ERC-4337 remains more gas-efficient for certain batch‑validation patterns (e.g., multiple UserOps from different accounts aggregated together). Newer 4337 bundler designs using EIP-7702 themselves — a hybrid approach — have started to blur the lines.
Security Model: Protocol‑Level vs. User‑Level Guarantees
Security is where the two standards diverge most. ERC-4337 relies on a contract (the EntryPoint) and an external network of bundlers to enforce constraints (e.g., nonce ordering, re‑entrancy protection, paymaster sponsorship). A bug in the EntryPoint could in principle affect all wallets that rely on it. Bundlers can also censor or re‑order UserOps (though economic incentives limit this).
EIP-7702 pushes validation into the protocol. The EVM itself checks that the account’s code is run and that the resulting state transitions are valid. There is no single point of failure like an EntryPoint. Additionally, the native nature means that EIP-7702 accounts inherit security properties from the transaction execution — for example, EIP-7702 code delegation is tied to the sender’s signature, preventing front‑running of the delegation itself.
- Attack surface: ERC-4337 has a larger attack surface due to external contracts (paymasters, aggregators, bundler nodes).
- Recovery: EIP-7702 accounts can be recovered via social recovery directly in the account’s code (native EOA delegation), while ERC-4337 wallets often require a separate recovery contract (e.g., Guardian modules).
- Illustration: A vulnerability in a shared EntryPoint contract could affect many ERC-4337 wallets at once, whereas a native account keeps its validation logic inside the account itself rather than in an external shared contract.
Adoption in 2026: Which Standard Do Major Wallets Use?
By 2026, ERC-4337 remains the more widely adopted approach, driven by inertia and tooling maturity. The largest ERC-4337 wallets — Argent, Zerion, Rainbow, and MetaMask’s smart wallet — have deeply integrated paymasters (e.g., Pimlico, Biconomy) and session keys for gaming. They also benefit from the widest range of third‑party integrations: most DeFi dApps and NFT marketplaces already have SDKs that expect ERC-4337 UserOps.
EIP-7702 has gained traction in ecosystems that adopted EIP-7702-style native account features early. Some wallets favor the native approach for its simplicity and lower gas.
A growing trend is the hybrid wallet: a single contract wallet that implements both ERC-4337’s EntryPoint interface and EIP-7702’s native execution path. A number of smart-account wallets are pursuing this hybrid design. Users get the best of both worlds: fallback to ERC-4337 when paymaster sponsorship is needed, and native mode for gas‑sensitive operations.
Comparison Table: ERC-4337 vs. EIP-7702 (2026 Snapshot)
| Dimension | ERC-4337 (Overlay) | EIP-7702 (Native) |
|---|---|---|
| Core mechanism | UserOperation mempool + EntryPoint contract | EIP-7702 delegate code in transaction execution |
| Gas overhead (L1 per tx) | ~60,000–80,000 gas overhead | ~10,000–15,000 gas overhead |
| Security model | Relies on EntryPoint contract correctness; bundler trust | Protocol‑level, no single point of failure |
| Wallet adoption (market share) | Majority (e.g., Argent, Rainbow, MetaMask smart wallet) | Smaller but growing |
| Middleware ecosystem | Very rich: Pimlico, Biconomy, Alchemy Account Kit, Stackup | Emerging: native modules, few paymasters |
| L2 compatibility | Works on all L2s via L2‑specific EntryPoints | Precompiled via RIP-7560; not yet on all L2s |
| Developer integration effort | Medium (use ERC-4337 SDKs, bundle with bundler) | Low (standard tx flow, but need EIP-7702 compliant client) |
| Key innovation | Paymaster sponsorship, aggregation, session keys | Native fee abstraction, no extra mempool |
Developer Experience: Building with Each Standard
From a developer’s perspective, ERC-4337 offers the advantage of a mature SDK stack. Alchemy Account Kit lets you spin up a smart wallet in minutes with built‑in bundler and paymaster endpoints. Pimlico provides advanced features like user‑op simulation and gas estimation. You also get easy access to ERC-6900 (modular account) and ERC-7821 (cross‑chain user ops). Complex patterns like session keys or batched transactions are well documented.
EIP-7702 requires a deeper understanding of the EVM execution model. To use it, a wallet must generate a delegate code signature that wraps the intended call. The code then runs during the same transaction that pays gas. There is no “UserOp” object, so legacy dApps that expect eth_sendUserOperation need special adapters. However, many wallet developers find the reduced dependencies a relief — no need to run or trust a bundler, and no extra hop to a relay.
Real example: A team building a DeFi yield aggregator in 2026 might choose ERC-4337 for the wizards (where paymaster sponsorship is needed to onboard new users) and EIP-7702 for the pro dashboard (where power users demand minimal gas). Their wallet SDK handles both via a unified account abstraction layer (e.g., ZeroDev’s universal AA SDK).
The Future: Will One Standard Win?
Many in the Ethereum community predicted that EIP-7702 would obsolete ERC-4337 entirely by 2026. That hasn’t happened. Instead, both coexist as layers of abstraction. ERC-4337 remains the default for user‑friendly onboarding (thanks to paymasters) and for smart contracts that need to act as accounts (e.g., DAO treasuries). EIP-7702 is the default for high‑frequency, low‑cost operations and for EOAs that want programmable access without deploying a full contract.
The real convergence is happening through hybrid approaches and protocol upgrades. EIP-7702 is already being used by bundlers to compress multiple UserOps into native transactions. In turn, ERC-4337’s modular account framework (ERC-6900) is being repurposed to manage the delegate code of EIP-7702 wallets. The two standards are becoming complementary: EIP-7702 provides the backbone, ERC-4337 the rich user‑experience layer.
“By 2028, I expect the distinction to be invisible to most developers. You’ll just use ‘account abstraction’ and the network picks the most efficient path.” — a common expectation in the Ethereum account-abstraction community.
How to Choose Between ERC-4337 and EIP-7702 in 2026
Every team’s context differs, but here are practical heuristics derived from real production experience:
- Choose ERC-4337 if: You need instant paymaster sponsorship for user acquisition, you rely on infrastructure like Pimlico or Alchemy, you are building on an L2 that does not yet support EIP-7702 (some smaller L3 chains still lack), or your wallet requires complex modular features (e.g., session keys, multi‑operator rules).
- Choose EIP-7702 if: Gas costs are your users’ top complaint, you are building for power users (traders, liquidators, bots), you want minimal trust assumptions (no bundlers, no EntryPoint), or you are launching a native L2 wallet that can enforce the standard from day one.
- Choose hybrid if: Your wallet targets both mainstream and advanced users, or you are a wallet infrastructure provider wanting maximum compatibility. Use a library that abstracts the choice — e.g., Candide’s modular AA framework.
No single answer fits all. The core trade‑off remains: ERC-4337 buys you ecosystem and tooling, EIP-7702 buys you efficiency and security. Evaluate your user persona and deployment chain carefully.
Common mistakes to avoid
- Assuming native account abstraction requires deploying a persistent smart contract — EIP-7702 actually uses temporary code delegation, which costs far less than deploying a full contract.
- Treating ERC-4337 and EIP-7702 as mutually exclusive; many wallets implement both and switch based on the use case.
- Neglecting L2 support: EIP-7702 is not uniformly available on all rollups; check if your target chain has activated EIP-7702 or a local equivalent (like RIP-7560).
- Overlooking bundler centralization risks in ERC-4337: relying on a single bundler can lead to censorship or front-running; use a decentralized bundler network (e.g., Stackup Network) or fallback to EIP-7702 for critical operations.
- Thinking EIP-7702 solves all gas costs — signature verification, especially using ECDSA or BLS, still consumes gas; choose the signature scheme to match your users' hardware (e.g., passkeys are cheaper than raw ECDSA).
Frequently asked questions
Can EIP-7702 wallets use paymasters like in ERC-4337?
Not directly — EIP-7702 lacks a built-in paymaster mechanism because transactions are paid from the sender's native balance. However, some projects use a 'delegated fee payment' pattern where a separate account covers gas, but this is less seamless than ERC-4337's native paymaster architecture.
Is EIP-7702 backward compatible with existing ERC-4337 wallets?
No, they use different transaction formats. A wallet built for ERC-4337 cannot automatically use EIP-7702 without code changes. However, many wallet SDKs now support both, requiring only a flag change in the wallet's configuration.
Which is better for high-frequency trading bots: ERC-4337 or EIP-7702?
EIP-7702 is generally better due to lower gas costs and reduced latency (no UserOperation mempool delays). For example, a bot on a native account can fit more transactions into the same gas budget by avoiding UserOperation overhead.
Does EIP-7702 require a new Ethereum wallet address?
No. With EIP-7702, an existing EOA can delegate code temporarily. The same address works as both a simple EOA and an account-abstraction wallet, depending on whether the delegate code is used in the transaction.
What are the main risks of using EIP-7702 today?
EIP-7702 is newer and less battle-tested. There have been no major exploits yet, but the EIP-7702 code delegation pattern has a subtle risk: if the delegate code is malicious or buggy, it can execute in the context of the EOA's storage and nonce. Always audit the delegate contract code.
Related reading
Track the entities behind the concepts
DeFi Intel maps 11,000+ protocols, tokens and companies to a typed knowledge graph — with live data, incidents and regulation.