THE FOUR PARTS EVERY ERC-4337 PAYMENT GOES THROUGH
UserOperation
intent, not a transaction
Bundler
prepays the gas
EntryPoint
one shared singleton
Paymaster
pays, optionally
ERC-4337 is usually introduced as “account abstraction without a hard fork,” which is accurate and explains almost nothing. This piece takes the system apart like a parts catalogue — each component gets what it is, what it is not, and where it moved the trust — then reassembles them into one full call and puts that road next to the one EIP-7702 opened in the Pectra hard fork.
If a wallet is no longer a private key, is it still an account? On Ethereum that is an engineering question with an uncomfortable answer, because it presses on one of the oldest hard boundaries in the protocol: an externally owned account is controlled by one key and can only emit simple transactions, while a contract account has code but can never initiate a transaction itself. That line was never a preference, it was protocol. So the real question is not how to make wallets nicer — it is what it costs to move a protocol boundary without touching the layer that enforces it.
The Boundary Nobody Was Allowed to Cross
The early attempts answered honestly and were stopped. EIP-86 and EIP-2938 both asked Ethereum to change its consensus rules so an account could validate on its own terms. Consensus rules change on one schedule: a hard fork. Both stalled for a structural reason, not for lack of demand or clever cryptography.
The shortest description I have found of the trade, and the one I keep repeating, comes from eco.com’s account-abstraction primer:
“It uses no EVM changes, no hard fork, no validator opt-in.”
ERC-4337 was submitted in September 2021 by Vitalik Buterin and others, and the trick it pulled was to stop asking. It does not touch the consensus layer; it builds a separate higher-layer system on top of the existing protocol and gives a new class of transaction-like objects their own waiting room.
ERC-4337 earns the phrase “account abstraction without consensus changes” because it did not move the boundary — it moved the job. The job is deciding whether an operation is legitimate, and ERC-4337 moved it out of protocol rules and into contract code.
And here is the sentence everything else here is a corollary of: it relocated trust, it did not remove trust. It traded “guaranteed by the protocol” for “guaranteed by code, audits and economic incentives.” You now trust one singleton shared by the whole ecosystem, a swarm of off-chain bundlers, and optionally a paymaster. Three counterparties where there was one rule.
The EntryPoint went live on mainnet on 1 March 2023, announced at WalletCon during ETHDenver by Ethereum Foundation researcher Yoav Weiss, audited — OpenZeppelin among others — before deployment. It evolved from v0.6 to v0.7.0 through 2024, and v0.7 sits at 0x0000000071727De22E5E9d8BAf0edAc6f37da032. Write that down.
A Dictionary, Part One: The Object, the Pool, and the Mover
UserOperation. A data structure packaging user intent: sender, nonce, callData, signature, paymasterAndData, and several gas limits. It is not a transaction — no validator is obliged to look at it, and it cannot enter the normal mempool. What it moved: the moment an operation becomes real is no longer “when a key signed it” but “when somebody with ETH decided to pay for it.”
Alt mempool. A second waiting room for UserOperations with its own RPC dialect. Not the canonical transaction mempool, not protected by the protocol’s gossip guarantees. What it moved: visibility. Whether your operation is seen now depends on which bundlers are listening, not on the network.
Bundler. An off-chain role that listens to the alt mempool, simulates each UserOperation off-chain (methods in the family of eth_estimateUserOperationGas), packs many into one ordinary Ethereum transaction calling handleOps(), and prepays gas in ETH from its own EOA. It earns the spread between what the UserOperations pay and its L1 cost. It is not a validator and it is not altruistic. What it moved: liveness. Your ability to transact is now somebody’s profit calculation.
Assemble those three and you already have a story: an object that is not a transaction sits in a pool the protocol does not know about, until a stranger with a spreadsheet decides it is worth fronting money for. Note what has not happened yet — nothing verified on-chain, no code run.

A Dictionary, Part Two: The Singleton and the Account
EntryPoint. One singleton contract per chain, shared by every ERC-4337 wallet. It holds the ETH deposits that pay for gas, manages the nonce per account, orchestrates the two loops, verifies each UserOperation before the wallet’s callData runs, and guarantees the bundler is repaid. It is not your wallet and it is not per-application — that is precisely the point and precisely the risk. What it moved: every ERC-4337 wallet implicitly trusts this one address, making it the most valuable audit target in the ecosystem. A bug here is not a bug in one wallet.
Smart Account. The user-side contract, upgradeable, and it must implement validateUserOp. Signature scheme, multi-factor rules, social recovery, session keys — all of it lives here instead of being hard-coded by the protocol. It is not a key; the key is now one input among several, or none at all. What it moved: the definition of “authorized” out of the protocol and into application code. For the underlying idea, see What Is a Smart Contract.
Assemble those two with the bundler and you get the real shape: the bundler calls EntryPoint, EntryPoint calls back into the account’s validateUserOp, and the account answers. A stranger triggers a contract that then asks the user’s own contract whether the stranger’s request is legitimate.
A Dictionary, Part Three: The Payer and the Compressor
Paymaster. An optional contract that pays gas for the user. It can sponsor unconditionally, accept the user’s ERC-20 instead of ETH, or apply allowlists and gating rules. It pre-funds ETH inside the EntryPoint and is responsible for the contents of paymasterAndData. It is not a fee market and it is not a charity — it is a contract with rules and a balance. What it moved: “who pays” from the protocol’s single answer (the sender, in ETH) to a negotiable business arrangement. See What Is Gas on Ethereum for why that payment existed, and What an ERC-20 Token Actually Is for what a paymaster might take instead.
Aggregator. An optional helper letting many UserOperations be verified together under one aggregated signature, BLS being the usual example. It is not a bundler — it submits nothing, it compresses verification. What it moved: cost. Signature verification stops scaling linearly with operation count, at the price of one more contract you depend on.
Assembling: One Call, Two Loops
The full sequence — the part worth memorising:
- The wallet builds a UserOperation and hands it to the alt mempool.
- A bundler simulates it off-chain and rejects it if simulation fails or it looks like it will not pay.
- The bundler sends one normal transaction to EntryPoint’s
handleOps(), paying gas from its own EOA. - Verification loop: EntryPoint calls
validateUserOpon the smart account, which checks the signature, the nonce, and whether gas can be paid. A named paymaster is validated too. - Execution loop: only after verification passes does EntryPoint unwrap
callDataand execute it against the account. - EntryPoint settles up, repaying the bundler from the account’s or the paymaster’s deposit.
Verification and execution are separate loops. That is the single most important structural fact in this whole design. Not a detail — the load-bearing beam. It is what makes off-chain simulation meaningful, and simulation is the only thing between a bundler and a free-gas attack.
Why the Verification Loop Has to Be Caged
Here is the attack the separation exists to stop. If verification code were unconstrained, a UserOperation could simulate fine and behave differently on chain — read a block hash, touch unrelated storage, call out to a contract that flips a value. The bundler pays real ETH either way. That is griefing: drain a bundler’s gas for free, at scale, at no risk to the attacker.
So the spec cages verification with simulation rules: reading block-level state (BLOCKHASH, NUMBER, TIMESTAMP) is forbidden beyond a very short tolerance; storage access is restricted to slots tied to that account or paymaster; arbitrary external calls are not allowed. The rule set was later numbered ERC-7562.
Read that as economics, not a security checklist. ERC-7562 exists to make off-chain simulation trustworthy, and trustworthy simulation is the precondition for a bundler agreeing to front money at all. No simulation guarantee, no bundlers. No bundlers, no ERC-4337. The cage is not defence in depth; it is the foundation.
An Honest Attack Surface
I will not pretend this is settled engineering. The surfaces I worry about:
- Paymaster drained. It holds a balance inside the EntryPoint, and its own rules are its only defence.
- Simulation passes, execution fails. The bundler eats the gas. A designed-in loss, hence aggressive simulation.
- The EntryPoint reentrancy model. Reentrancy is permitted through the
innerHandleOppath; the lock protects specific accounting operations, not the entire call stack. “There is a reentrancy guard, therefore it is safe” is not a valid inference. - Cross-chain signature replay. A signature valid on one chain may be valid on another unless the scheme binds chain id explicitly.
- Over-delegated EntryPoint authority. If a wallet grants
address(entryPoint)broad rights, anyone reaching the execution path through the EntryPoint may inherit them. - Upgradeability drift. The wallet is upgradeable, so “the audited implementation” and “the implementation currently deployed” are not the same thing, and only one protects you today.

The Other Road: EIP-7702
EIP-7702 is the other answer to the same question, and it took the road ERC-4337 refused: it is a protocol-level upgrade, shipped with the Pectra hard fork on 7 May 2025, introducing a new transaction type, SET_CODE.
An EOA signs an authorization_list — tuples of chain_id, address, nonce, y_parity, r, s — and its code field becomes a 23-byte delegation designator: 0xef0100 || address. Calls to that EOA are forwarded to the implementation contract but execute in the EOA’s own storage and balance context. Six things follow, and the fifth is the one people skip:
- The
0xefprefix reuses a code prefix EIP-3541 had already banned for normal contracts, which is how a delegated EOA is marked as special rather than looking like a contract. - Revocation is another transaction: point the delegation at the zero address.
- A tuple with
chain_id = 0can be replayed on every EVM chain. A feature with teeth. EXTCODESIZEon such an account returns 2 — the length of0xef01— andEXTCODEHASHreturnskeccak256(0xef01). Every contract that decided “this is an EOA” by testingEXTCODESIZE == 0is now wrong.- The original private key is still there, so it can always override any contract rule with a fresh 7702 transaction — social recovery, spending limits, session keys, all of it. EIP-7702 gives you a programmable account one key can unilaterally rewrite. Not an implementation bug; it is the deal.
- You can point the delegate at an ERC-4337 wallet implementation, so the EOA gets bundler and paymaster machinery while keeping its address — the combination the proposal’s authors explicitly encourage.
Safe, ZeroDev Kernel, Alchemy Light Account and Argent are reference implementations of these account contracts; named once, not ranked.
| EOA | Contract-based smart account | ERC-4337 smart account | EIP-7702 delegated EOA | |
|---|---|---|---|---|
| Can initiate a transaction | Yes, with a key | No | Only via a bundler | Yes, with a key |
| Where validation lives | Protocol | Its own code, its own infra | validateUserOp, via EntryPoint | Delegated code, in EOA context |
| Who pays gas | Sender, in ETH | Varies by that wallet | Sender deposit or paymaster | Sender, or paymaster if delegated to 4337 |
| Address changes on upgrade | N/A | Yes — new deployment | No | No |
| Needed a hard fork | N/A | No | No | Yes |
| Key can be overridden by code | No | Yes | Yes | No — the key always wins |
These are not competitors. ERC-4337 is the better road when building a wallet from nothing, because it is mature and the tooling exists. EIP-7702 is the better road for the installed base of EOAs that cannot reasonably change address, migrate balances, or give up their history, their ENS name, or airdrop eligibility.
How I Judge Systems Like This
I have a short method for systems that claim to remove trust, and ERC-4337 is a good workout for it. First: ask where the trust went, not whether it disappeared. It never disappears. ERC-4337 answers precisely: one singleton, a bundler market, an optional paymaster. Second: ask whether anything here has protocol-level enforcement. The honest answer is no, and that is the entire cost of avoiding a hard fork — the rules are contract rules, upheld by code, audit and incentive rather than by consensus. Third: ask what the failure mode looks like when the system is merely attempting something. The good failure mode degrades back to the status quo; the bad one is funds disappearing. ERC-4337 mostly degrades: a bundler refuses, an operation is not included, you fall back to a plain transaction. Where it does not degrade — EntryPoint bugs, over-delegated authority, upgrade drift — is where I would spend my attention.
- 01Read the
validateUserOpflow in the EntryPoint at0x0000000071727De22E5E9d8BAf0edAc6f37da032on a block explorer: confirm verification and execution are two separate loops. - 02Read ERC-7562 for the banned opcodes and the storage-slot scoping rule a bundler’s simulation enforces.
- 03Read the EIP-7702 delegation-designator section to see how the 23 bytes of
0xef0100 || addressare laid out. - 04Look up SET_CODE (type 0x04) in the Pectra hard fork docs and check the
chain_id = 0replay case. - 05Check what your contracts assume about
EXTCODESIZEbefore deploying them beside a delegated EOA.
(The End)


