TEST ANY EIP
on the EVVM stack▊
EVVM is where protocol-level experiments get modeled at the contract layer. Bring an EIP and your own AI key — the Lab reads it, agrees with you on what it is, maps it onto the EVVM core, and hands back documented .sol contracts.
// why evvm eip lab
The bottleneck isn't the EIP.
It's getting to running code.
Going from an EIP to contracts you can reason about usually means days of plumbing. The Lab compresses that — and is honest about what it can and can't prove.
Built for protocol experiments
EVVM's core contracts are modifiable, so an EIP — new signatures, nonce models, account abstraction, privacy, gas changes — can be modeled at the contract layer and exercised directly. It's the natural place to test protocol-level ideas.
Solidity + justification
Every run produces exactly two things: the documented .sol files and a per-contract justification. Sharp scope. No half-finished extras to clean up afterward.
Mocks called by name
Heavy dependencies (ZK proofs, exotic hashes, precompiles) get mocked — and every mock carries an explicit limitation: what it stubs and what claims it does NOT support. Real vs. stubbed, at a glance.
// how it works
Four phases, end at Solidity.
The EVVM EIP Lab drives all four. You make the calls it can't — which path when an EIP requires another draft EIP, which sub-experiment when the scope is huge.
Upload
Load your EIP — paste the full text, or drop links (eips.ethereum.org, an Ethereum Magicians thread, a repo). No length limit. An important EIP can be hundreds of lines, and every line can matter.
Read & Agree
The Lab reads it and tells you what it is — status, surface, the real behavioral change. Then it asks: did I get the intent right? You correct it until you both agree. No forced word limit.
Map the surface
The technical conversation: which implementation shape (modify the core, add a service, or an external adapter), which dependencies to vendor / mock / simulate / defer, which EVVM contracts change and how.
Download .sol
The deliverable: documented, commented Solidity for the EVVM stack — modified core, new services, mocks — plus a per-contract justification. Download the package and take it from there.
// comparison
vs. rolling your own
Not better at everything. Better at the parts most efforts skimp on: agreeing on intent up front, documenting what's real vs. stubbed, and stopping before scope explodes.
| dimension | traditional | evvm eip lab |
|---|---|---|
| Time to running code | Days reading the EIP, finding the right surface, writing plumbing | A working session — read, agree, map, download |
| Shared understanding | You hope the implementer read the EIP the same way you did | Phase 2 makes you both agree on the intent before any code |
| Output shape | Code + half-finished extras, mixed maturity | Documented Solidity + per-contract justification (deliberately narrow) |
| Mock honesty | 'Good enough' mocks; caveats buried in PR comments | Every mock states what it stubs and what it does NOT prove |
| Big EIPs | One tangled attempt at everything at once | Decomposes into clean sub-experiments when the scope is huge |
| Cost visibility | No idea what the AI run cost you | Live token meter every run — your key, your spend, your data |
// demos
Three EIPs, three shapes
One Core-modification, one new-service, one mock-heavy shielded-pool service. Open the demo to explore the contracts, or download the EVVM package directly.
// roadmap (raw)
Where this is going.
A rough, honest plan — subject to change. EVVM EIP Lab is early; this is the direction, not a commitment of dates.
Alpha — testable
Where we are today. A very alpha, testable version: bring an EIP and your own provider key, run the four phases, get documented Solidity. Rough edges, breaking changes, output not guaranteed to compile.
Alpha — polished
Still alpha, still testable — but polished. Steadier runs, cleaner output, fewer rough edges across providers and models. The same flow, more reliable.
Scaffold-EVVM local
Connected to scaffold-evvm: take the generated contracts straight into local compilation and deployment, so you can compile and run your EIP experiment locally instead of just reading the .sol.
Testnet-ready
Scaffold-evvm compatible plus ready for EVVM testnet deployment — an end-to-end path from EIP to a deployed experiment on the EVVM testnet.
// questions
faq.txt
›Can I run my own EIP?
›What does a run produce?
.sol files (modified core, new services, mocks) plus a per-contract justification, bundled into a downloadable package. No tests, no deploy scripts, no EIP draft — the deliverable is documented Solidity.›Whose API key is used, and is it safe?
›How should I test the contracts the Lab gives me?
experiments/. See the scaffold-evvm docs and how to make an EVVM service. The downloaded package includes a guide for this.›How does it handle EIPs that depend on other draft EIPs?
›What about really large EIPs?
›Why track token counts?
›Is it open source?
g@evvm.org.