Why
The instructive move is the one that looks like a downgrade. Today the deposit contract knows what a validator credential is: 48 bytes of public key, 96 bytes of signature metadata. Those constants are the contract holding an opinion about a cryptographic scheme it does not own, and every future scheme is blocked by it. The draft does not answer that by teaching the contract a second scheme — it makes the field variable-length and moves validity elsewhere. The contract stops understanding credentials and becomes transport for them. That is the generalisable technique, and it is counterintuitive precisely because the instinct in a migration is to add knowledge rather than remove it.
The retirement mode is the other half, and its irreversibility is the feature, not the risk. A one-way system call reads like danger — no rollback, no undo, no second chance. But consider the reversible version: if BLS retirement could be lifted, then no new BLS deposits, ever is not a guarantee, it is a current setting, and anyone who captures the switch restores the old scheme. The property being bought is exactly the impossibility of restoration. A switch that can be flipped back does not retire anything; it pauses it.
Which relocates the whole design problem to before the flip. A reversible change can be tested in production, because the cost of being wrong is a revert. An irreversible one moves every test in front of the switch and leaves nothing behind it, so the real question is never how do we build the switch — it is what evidence would be sufficient to flip it, and can that evidence be gathered on the live system without flipping. That is a specification problem wearing a smart contract's clothes, and it is why this draft is worth reading even by someone who will never touch BLS.
The reason variable-length is hard is aggregation, and it is worth naming. BLS12-381 gave the consensus layer more than a size: it gave aggregation. Hundreds of thousands of attestations per slot are tractable because n signatures still occupy 96 bytes and verification finishes in a pairing. Most post-quantum candidates — hash-based, lattice-based — either do not aggregate or aggregate far more expensively, so this draft is not proposing a migration. It is proposing something more modest and more useful: clear the deposit contract out of the way now, so it is not the obstacle on the day a migration is actually decided.
And the change that needs an EIP is a type, not an algorithm. bytes48 pubkey becomes bytes pubkey plus a scheme identifier. That one line is large because the deposit contract is the only execution-layer contract the beacon chain reads, and its log format is hardcoded into every client, every staking service and every indexer. The hardest code to change is not complex code — it is widely-read code, and nothing in the diff tells you which kind you are touching.
The line to this project is direct. A settlement contract accumulates opinions the same way: a signature format, an oracle payload shape, a resolution encoding, token decimals. Each one is a constant today and a migration problem later, and the day a scheme underneath has to change, the only two options are the ones in this draft — make the contract variable-length and let something else judge validity, or build a one-way door and be certain before walking through it. storage-collision-admin-takeover is the reminder of what a switch is when nobody is watching it: an admin power, and the invariant that guards it belongs in the same commit as the switch.
How it works
Two mechanisms, and what each one actually buys
| Mechanism | What it changes | What it buys | What it costs |
|---|---|---|---|
| Variable-length credentials (up to 8,192 bytes, from fixed 48 / 96) | The contract stops encoding one scheme's dimensions | Any future scheme fits without touching the contract | Validity has to be judged somewhere else, and that somewhere becomes load-bearing |
| BLS retirement mode (system call, one way) | New deposits under the old scheme become impossible | A guarantee rather than a setting — nobody can restore it | Every test moves in front of the flip; there is no after |
Three modes, and the draft's actual status
| Mode | What it permits | Reversible? |
|---|---|---|
disabled |
No deposits | — |
BLS enabled |
BLS onboarding, as today | — |
BLS retired |
No call can re-enable BLS onboarding | No |
Status as reported: draft, awaiting editor review, with contract address and activation timing undecided. And 8,192 bytes reads generous until you price hash-based signatures — for a SPHINCS+-class scheme it is headroom, not abundance. Meanwhile EIP-8141 opens opt-in quantum-safe signatures at the execution layer while this opens the same door at the consensus layer: two layers moving the same direction at once.
The pattern worth stealing
Do not teach the contract the new thing. Stop it knowing the old thing. A contract that validates a specific format must be changed for every new format; a contract that carries opaque bytes and defers judgement never needs changing again for that reason. The trade is explicit: the judgement does not vanish, it relocates — and wherever it lands inherits the security weight the constants used to carry.
Note the residue, too. Variable up to 8,192 bytes is still an opinion, just a looser one. Every migration of this shape leaves a bound behind, and the bound is the next generation's constant.
Designing a one-way door
| Question | Why it decides the design |
|---|---|
| What evidence is sufficient to flip? | There is no rollback, so the flip criterion is the safety mechanism |
| Can that evidence be gathered without flipping? | If not, the switch cannot be justified, only risked |
| What is the granularity? | One global flip, per-scheme, or per-credential-type — coarser is simpler and less recoverable |
| Is there a delay in front of it? | A timelock is the only undo available, and it undoes the decision, never the state |
| Who can call it, and what watches them? | A one-way switch is an admin power; the invariant guarding it belongs in the same commit |
The inventory this project can build today
Every constant in a settlement path that describes something the contract does not own is a future migration:
| Opinion held today | Could it become variable-length? |
|---|---|
| Signature scheme and length | Usually yes — verification can move to a precompile or a verifier contract |
| Oracle payload encoding | Yes, if resolution logic reads a decoded struct rather than raw offsets |
| Resolution record shape | Harder — settlement genuinely has to understand outcomes |
| Collateral token decimals | Yes, and this one bites earliest in practice |
| Address size | Rarely considered, and the first thing a different chain breaks |
Producing that table costs an afternoon and is useful even if no migration ever happens, because it is also the list of assumptions a second chain would violate. Reads with quick-slots-10s, which is the same exercise for time.
Review clarification
Protocol proposal first, design principle second
The immediate subject is an Ethereum protocol migration affecting the execution layer, consensus clients, validator onboarding, staking services and indexers. The reusable lesson is not an official Ethereum policy: a contract should understand only what it needs to enforce its own invariants. The current deposit path is already closer to transport than to a full BLS verifier, so the direction is better described as BLS-shaped transport → scheme-neutral transport. Complexity moves to the consensus or verifier layer; it does not disappear.
Split at trust and change boundaries
MarketFactory → EventMarket → fixed IResolver
├─ ChainlinkResolver
├─ CommitteeResolver
└─ TLSProofResolver
EventMarket should keep positions, collateral, finality and payout invariants together so redemption remains atomic. A resolver converts vendor-specific evidence into a canonical {status, outcome, resolvedAt} and receives no arbitrary custody authority. Pin it when the market is created; approve replacements only for future markets.
Do not split because a function is long. Split when security authority, upgrade cadence, failure mode or implementation choice genuinely differs; otherwise use an internal function or library. Variable length must remain bounded for gas and denial-of-service safety. Design the core around stable economic invariants and place changing formats behind bounded, versioned interfaces.