If your wallet shows that your Ethereum address is “delegated” to a contract you no longer trust, or that you never meant to approve, the fix is a second EIP-7702 authorization that points at the zero address. That one signed tuple tells the protocol to wipe the delegation and turn the address back into a plain externally owned account. The parts people get wrong are the nonce, the chain, and the belief that a successful receipt proves the reset happened.

This piece walks through the mechanics with the rules taken from the EIP-7702 specification and a real revocation read from Ethereum mainnet on November 7, 2026.

What a delegation actually is

EIP-7702 went live on Ethereum mainnet with the Pectra upgrade on May 7, 2025 at 10:05:11 UTC. It added transaction type 0x04, which carries an authorization_list of tuples [chain_id, address, nonce, y_parity, r, s]. Each tuple is signed by the account that wants to delegate (the spec calls it the authority), and anyone can submit the transaction that carries it.

When a tuple is valid, the protocol writes 23 bytes into the authority’s code: 0xef0100 followed by the 20-byte delegate address. The spec calls this a delegation indicator. From then on, any call to your address runs the delegate’s code in your account’s context, with your balance and your storage. The delegation persists until another valid authorization replaces or clears it. It does not expire.

The revocation tuple

The spec gives one special case. If the tuple’s address is 0x0000000000000000000000000000000000000000, the protocol does not write a delegation indicator. It “clears the account’s code by resetting the account’s code hash to the empty code hash” (0xc5d2…a470), as the behavior section of EIP-7702 puts it.

So a revocation is an ordinary type-4 transaction whose authorization list contains a tuple signed by your key with:

Field Value for a revocation Why it matters
chain_id The chain you are cleaning, for example 1 for Ethereum mainnet A tuple is accepted only if its chain ID is 0 or the current chain’s ID
address 0x0000…0000 Triggers the code reset instead of a new delegation
nonce Your account’s nonce at the moment the tuple is processed A mismatch makes the protocol skip the tuple
y_parity, r, s Your signature over keccak(0x05 ‖ rlp([chain_id, address, nonce])) Proves the tuple came from your key

Sending ETH to the zero address is not a revocation. It is a burn. The reset only happens through a signed authorization tuple inside a type-4 transaction.

The nonce trap when you send it yourself

The spec processes the authorization list “after the sender’s nonce is incremented” (EIP-7702, Behavior). If the same account both sends the transaction and signs the tuple, the transaction consumes nonce n first, and by the time the tuple is checked the account’s nonce is n + 1. A tuple signed with n fails the check and is skipped.

The mainnet example below shows the rule in practice. Transaction 0x9d97fbcf1058b932410053d027689bc3fcd3b63277ddf032113e416dc80d87ef, included in block 26,360,821 on November 7, 2026, was sent by 0x33d8…776a to itself with empty calldata. Its transaction nonce is 11; its single authorization tuple targets the zero address with nonce 12. After it was mined, eth_getCode for that address returned 0x. We read both values through the standard Ethereum JSON-RPC methods eth_getTransactionByHash and eth_getCode.

When a second account submits the transaction (a sponsored revocation), the authority’s nonce does not move before the tuple is checked, so the tuple uses the authority’s current nonce n. If you build the transaction by hand, this is the first thing to check.

A successful receipt does not prove the reset

This is the detail that most often misleads. In EIP-7702, if any check on a tuple fails (wrong chain ID, wrong nonce, bad signature, or an authority that holds real contract code), the protocol will “immediately stop processing the tuple and continue to the next tuple in the list” (spec). The transaction itself can still succeed. A receipt with status: 1 only tells you the outer transaction executed.

The opposite also holds: if the transaction’s execution reverts, delegation changes that were already processed are “not rolled back.” Either way, the receipt is the wrong evidence. The account code is the right evidence.

How to check the result

Call eth_getCode for your address on the chain in question, at latest:

  • 0x means no code: the address is a plain account and no delegation is active.
  • 23 bytes starting with 0xef0100 mean a delegation is active. The remaining 20 bytes are the delegate. For example, on November 7, 2026, eth_getCode for 0xd8d97db2a8caec33d58420aaf637cb41058cb58d returned 0xef010063c0c19a282a1b52b07dd5a65b58948a07dae32b, which decodes to prefix ef0100 and delegate 0x63c0c19a282a1b52b07dd5a65b58948a07dae32b.
  • Any other code means the address is an actual contract, not a delegated account, and EIP-7702 authorizations from it are rejected.

The spec also notes that EXTCODESIZE on a delegated account returns 23, the length of the indicator, rather than the size of the delegate’s code (EIP-7702, Delegation indicator). Tools that inspect code length see the indicator, not the wallet logic.

What it costs: 36,800 gas, worked out

The intrinsic cost of a type-4 transaction is the EIP-2930 base of 21,000 gas plus calldata and access-list costs, plus PER_EMPTY_ACCOUNT_COST of 25,000 for every tuple (EIP-7702, Gas Costs). For a revocation with no calldata and no access list:

  • Charged up front: 21,000 + 25,000 = 46,000 gas.
  • Because your account already exists, the spec adds PER_EMPTY_ACCOUNT_COST − PER_AUTH_BASE_COST = 25,000 − 12,500 = 12,500 gas to the refund counter.
  • EIP-3529 caps refunds at gas used ÷ 5, so the refund is min(12,500, 46,000 ÷ 5) = 9,200 gas.
  • Net: 46,000 − 9,200 = 36,800 gas.

The mainnet revocation above used exactly 36,800 gas, and so did the other single-tuple revocations with empty calldata we inspected in the same sample. At the base fee of about 0.042 gwei we read from block 26,361,401 that morning, 36,800 gas is roughly 1,550 gwei, or about 0.0000016 ETH before any priority fee. Fees change block to block, so treat that as a snapshot, not a quote.

One reset per chain

Code is per-chain state. A delegation on Ethereum mainnet is a different fact from a delegation on another EVM network, even at the same address. A tuple signed with chain_id = 0 is valid on any chain where the nonce matches (spec), and the spec’s rationale says plainly that universal deployment is the purpose of chain ID 0. So if you ever signed a chain-0 authorization, check eth_getCode on each network you use, and clear each one with its own revocation.

What revocation leaves behind

Clearing the code removes the pointer. It does not undo what the delegate already did:

  • Storage stays. The spec says clearing account storage “is not natively offered by the protocol” and suggests a special-purpose delegate if you need it (EIP-7702, Storage management). If you later delegate to a different contract, leftover slots from the old one can collide with the new layout.
  • Token approvals stay. An ERC-20 allowance granted while the delegate ran lives in the token contract, not in your account. Review it separately; our explainer on ERC-20 token allowances covers how to read and reduce them.
  • Moved funds stay moved. Revocation is forward-looking. It cannot reverse a transfer that already confirmed, which our piece on Ethereum transaction receipt status explains in more detail.
  • A stolen key stays stolen. Anyone holding your private key can sign a fresh authorization with your next nonce. If the delegation came from a compromised seed phrase, clearing it buys time to move assets to a new wallet; it does not secure the old one.

What our mainnet sample shows

We read 600 consecutive Ethereum mainnet blocks, 26,360,788 to 26,361,387 (05:08 to 07:08 UTC on November 7, 2026), through a public JSON-RPC node:

Measure Count
Transactions in the sample 144,473
Type-4 (EIP-7702) transactions 2,095 (about 1.5%)
Authorization tuples carried 2,801
Tuples pointing at the zero address (revocations) 38, in 37 transactions
Tuples signed with chain_id = 0 0
Distinct delegate contracts 61

Two hours of blocks is a small window, so these numbers describe that morning rather than a trend. They do show that revocations are routine on mainnet, and that in this sample every tuple was scoped to chain ID 1 rather than to all chains.

Reporting & Sources