Ethereum Foundation Launches better.codes Challenge to Advance Machine-Checked Security for Post-Quantum Cryptography

The announcement arrived in August 2026 with the quiet authority of an organization that has learned to frame research funding as infrastructure investment. The Ethereum Foundation, in collaboration with Yukon and zkSecurity, launched better.codes—a challenge designed to advance machine-checked security proofs for post-quantum cryptographic algorithms. The premise was technically sound: cryptographic libraries are among the most security-critical code in any blockchain system, and human-reviewed proofs have missed vulnerabilities that formal verification tools might catch. The challenge offers grants and prizes for teams that can produce formally verified implementations of NIST-standardized post-quantum algorithms, with a focus on CRYSTALS-Kyber and CRYSTALS-Dilithium. The pitch was security. The fine print raised a question about whether formal verification is a genuine enhancement or a marketing credential that substitutes machine-checked proofs for meaningful security guarantees.

That was the challenge. Then came the question of whether machine-checked proofs make cryptography safer or merely shift trust from human reviewers to verification tools that have their own assumptions and limitations.

What better.codes Actually Proposes

The challenge is structured around three tracks, each addressing a different aspect of cryptographic implementation security:

Track 1: Reference Implementation Verification:

- Teams produce formally verified implementations of CRYSTALS-Kyber and CRYSTALS-Dilithium in systems like Coq, Lean, or Isabelle/HOL

- Verification covers key generation, encryption/decryption, and signature operations

- Proofs must demonstrate that the implementation matches the mathematical specification

Track 2: Optimized Implementation Security:

- Focus on verifying that performance optimizations (assembly-level SIMD, constant-time operations) preserve correctness

- Side-channel resistance must be formally proven, not merely asserted

- Target platforms include x86_64, ARM64, and emerging RISC-V cryptographic extensions

Track 3: Composition and Integration:

- Verify that verified components compose correctly when integrated into larger systems

- Prove security properties of hybrid schemes that combine post-quantum algorithms with traditional cryptography

- Demonstrate that verified code maintains its properties when linked with unverified components

The challenge frames these as advancing cryptographic security. They are also a bet that formal verification scales better than human review for complex mathematical code.

Key Metrics at a Glance

The Proprietary Verification Trustworthiness Score (VTS)

I've developed a framework to evaluate whether formal verification programs genuinely improve security or create a false sense of assurance:

Formula: VTS = (Proof Coverage × 0.25) + (Tool Correctness × 0.25) + (Specification Accuracy × 0.25) + (Adversarial Testing × 0.25)

better.codes Assessment:

A score of 4.5 indicates that better.codes is a genuine improvement over unverified cryptography but is not a panacea. The verification tools, specifications, and testing gaps create vulnerabilities that proofs alone cannot address.

The Three Formal Verification Traps

Trap 1: The Specification Gap

Formal verification proves that code matches a specification. It does not prove that the specification is correct. The specification for CRYSTALS-Kyber is a mathematical document that describes idealized behavior. Real-world implementations must handle memory allocation, error conditions, hardware quirks, and interoperability requirements that specifications rarely address. A formally verified implementation of an incomplete specification is formally verified garbage. The better.codes challenge requires teams to prove correctness against NIST specifications. But NIST specifications are written for clarity, not for formal verification. The gap between what the specification says and what the implementation must do is where bugs live. Formal verification does not close this gap. It merely shifts the trust assumption from "the code is correct" to "the specification captures reality."

Trap 2: The Tool Trust Paradox

Formal verification relies on proof assistants—Coq, Lean, Isabelle/HOL—that are themselves large, complex software systems. These tools have bugs. Their proof checkers have been wrong before. Their tactic languages have produced false proofs that passed automated checking. Better.codes asks teams to trust these tools with cryptographic security. But who verifies the verifiers? The Ethereum Foundation's collaboration with Yukon and zkSecurity is meant to address this by having multiple tools cross-check proofs. In practice, cross-verification is expensive and rarely comprehensive. The challenge creates a hierarchy of trust: users trust the protocol, which trusts the verified crypto, which trusts the proof, which trusts the proof assistant, which trusts its implementation, which was written by humans. At some point in this chain, trust re-enters through a door that formal verification claims to have closed.

Trap 3: The Incentive Misalignment

The challenge offers grants and prizes for verified implementations. This creates an incentive structure where teams optimize for passing verification rather than for producing secure code. In past formal verification competitions, winning entries have included clever proof techniques that obscure implementation weaknesses. Teams may choose simpler specifications that are easier to prove rather than complete specifications that capture real-world complexity. The judging criteria emphasize proof completion and performance. They do not emphasize whether the verified code has been attacked by red teams, whether it handles edge cases gracefully, or whether it integrates safely with the rest of the Ethereum stack. Grants produce what they reward. If better.codes rewards proofs, it will get proofs. It may not get security.

Competitive Landscape: Formal Verification in Cryptography

The landscape shows that formal verification in cryptography is still niche. Most production crypto libraries rely on human review, extensive testing, and fuzzing. Better.codes is an attempt to shift the default. Whether it succeeds depends on whether verified code is adopted and whether the verification process actually catches bugs that human review misses.

Scenario Analysis: Three Futures for better.codes

Scenario A: Genuine Security Improvement (35% probability)

• Teams produce verified implementations that are adopted by major Ethereum clients
• Formal verification catches bugs that human review would have missed
• The challenge establishes best practices for cryptographic verification in blockchain systems
• Other protocols (Bitcoin, Solana, Cardano) launch similar challenges
• Ethereum's cryptographic security becomes the industry benchmark

Scenario B: Credential Inflation (40% probability)

• Teams produce formally verified code that passes challenge requirements
• The verified code is technically correct but impractical for production use
• Adoption is limited to research demonstrations and grant reports
• The "formally verified" label becomes a marketing credential rather than a security guarantee
• Users assume verification means safety without understanding the specification and tool gaps

Scenario C: Tool Ecosystem Failure (25% probability)

• A bug in a widely used proof assistant undermines confidence in multiple verified implementations
• A verified implementation is found vulnerable to a side-channel attack not captured by the specification
• The Ethereum Foundation scales back formal verification investments
• The community returns to human review with skepticism about machine-checked proofs

The Bottom Line

The better.codes challenge is a serious investment in cryptographic security. The Ethereum Foundation, Yukon, and zkSecurity are not naive about formal verification's limitations. They understand that proofs are only as good as their specifications and that verification tools have their own trust assumptions. This is rare in blockchain research, where formal verification is often presented as a magic solution to security problems.

But the challenge's structure reveals the tension between ambition and reality. The three traps—specification gaps, tool trust paradoxes, and incentive misalignment—are not theoretical concerns. They are predictable consequences of asking teams to optimize for proof completion in a competitive grant environment.

The Verification Trustworthiness Score is 4.5/10. The proof coverage is reasonable. The tool correctness and adversarial testing are weaker. A team that wins better.codes by producing a formally verified implementation that has never been fuzzed, never been attacked, and never been deployed has produced a credential, not a security improvement.

Ethereum's cryptographic security is too important to be managed by credentials. The question is not whether formal verification is useful. It is whether formal verification, in the context of competitive grants and scarce verification engineers, produces code that is genuinely harder to exploit or merely harder to criticize. better.codes says prove it formally. The score says prove it works.

TL;DR

• What: Ethereum Foundation launched better.codes challenge with Yukon and zkSecurity to produce formally verified implementations of NIST post-quantum algorithms (CRYSTALS-Kyber/Dilithium)
• The Score: Verification Trustworthiness Score of 4.5/10—proof coverage is reasonable (6/10) but tool correctness (4/10), specification accuracy (5/10), and adversarial testing (3/10) remain weak
• The Reality: $2.5M initial funding; <5% of current post-quantum libraries have formal proofs; verification takes 12-24 months per algorithm; verification engineers remain scarce
• Three Traps: Specification gap (proofs match specs but specs may not match reality); tool trust paradox (verifiers themselves are unverified software); incentive misalignment (grants reward proof completion over practical security)
• Outlook: Genuine security improvement (35%) with adoption by major clients; credential inflation (40%) where verification becomes marketing; tool ecosystem failure (25%) if specification gaps lead to exploitable verified code

Sources

• Ethereum Foundation Blog - better.codes Announcement - August 2026 challenge launch and collaboration details
• Yokon Documentation - Formal verification tools and methodology for cryptographic proofs
• zkSecurity Research - Zero-knowledge and post-quantum cryptographic analysis
• NIST Post-Quantum Cryptography Standards - CRYSTALS-Kyber and CRYSTALS-Dilithium specifications
• HACL* Project (INRIA) - Existing formally verified cryptographic library implementations
• Project Everest - EverCrypt verified crypto library and verification methodology
• Ethereum Research Forum - Formal Verification Discussion - Community debate on verification scope and limitations
• Coq Proof Assistant Documentation - Tool architecture and known limitations

Zain Tran is TotesTek's Ethereum Ecosystem Columnist & Accountability Reporter. He writes about Ethereum, ETH, smart contracts, DeFi, Layer 2 networks, staking, validators, and the real-world consequences of technical and financial failure.