Six Parts, One Shared Contract: How ERC-4337 Account Abstraction Actually Works

ERC-4337 moved transaction validation out of the protocol and into contract code: UserOperations, an alt mempool, bundlers, one singleton EntryPoint, paymasters and aggregators. It relocated trust rather than removing it, and EIP-7702 opened a second road in Pectra.

THE FOUR PARTS EVERY ERC-4337 PAYMENT GOES THROUGH

01
UserOperation

intent, not a transaction

02
Bundler

prepays the gas

03
EntryPoint

one shared singleton

04
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.

2023-03-01the day the EntryPoint went live on Ethereum mainnet, announced at WalletCon during ETHDenver

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.

Six Parts, One Shared Contract: How ERC-4337 Account Abstraction Actually Works
U.S. National Archives, Public domain, via Wikimedia Commons

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 validateUserOp on 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 callData and 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 innerHandleOp path; 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.
Six Parts, One Shared Contract: How ERC-4337 Account Abstraction Actually Works
U.S. National Archives, Public domain, via Wikimedia Commons

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.

0x04the transaction type EIP-7702 added in the Pectra hard fork of 7 May 2025

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 0xef prefix 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 = 0 can be replayed on every EVM chain. A feature with teeth.
  • EXTCODESIZE on such an account returns 2 — the length of 0xef01 — and EXTCODEHASH returns keccak256(0xef01). Every contract that decided “this is an EOA” by testing EXTCODESIZE == 0 is 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.

EOAContract-based smart accountERC-4337 smart accountEIP-7702 delegated EOA
Can initiate a transactionYes, with a keyNoOnly via a bundlerYes, with a key
Where validation livesProtocolIts own code, its own infravalidateUserOp, via EntryPointDelegated code, in EOA context
Who pays gasSender, in ETHVaries by that walletSender deposit or paymasterSender, or paymaster if delegated to 4337
Address changes on upgradeN/AYes — new deploymentNoNo
Needed a hard forkN/ANoNoYes
Key can be overridden by codeNoYesYesNo — 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.

  1. 01Read the validateUserOp flow in the EntryPoint at 0x0000000071727De22E5E9d8BAf0edAc6f37da032 on a block explorer: confirm verification and execution are two separate loops.
  2. 02Read ERC-7562 for the banned opcodes and the storage-slot scoping rule a bundler’s simulation enforces.
  3. 03Read the EIP-7702 delegation-designator section to see how the 23 bytes of 0xef0100 || address are laid out.
  4. 04Look up SET_CODE (type 0x04) in the Pectra hard fork docs and check the chain_id = 0 replay case.
  5. 05Check what your contracts assume about EXTCODESIZE before deploying them beside a delegated EOA.

(The End)

Ethereum

Six Functions, Two Mappings, One Promise: What an ERC-20 Token Actually Is

2026-10-18 5:53:53

Ethereum

If the Operator Vanishes Tomorrow: The Only Question That Separates One L2 From Another

2026-10-20 23:52:59

❯
Profile
Cart
Coupons
Search