In this guide
- Formal verification is machine-checked mathematical proof that software meets a written rule for every possible input.
- A proof covers every input for the rule you wrote; an audit samples the inputs an expert chose.
- Trillions of dollars of repo and collateral already settle through on-chain code every month. On a blockchain there is no second chance, so the rules that move money must be proven before they run.
- Proofs became affordable in 2026 because AI writes them and an independent checker verifies them. Google DeepMind verified Signal's production code in four weeks.
- The same year showed the limits: overstated claims, wrong specifications, and bugs in a checker itself.
- Proofs do not cover stolen keys, phished signers or what a screen shows. Bybit lost about $1.5 billion through none of the code.
- Four questions test any "formally verified" claim: which properties, which code, which assumptions, and can we re-run it.
- Every EternaX solution comes with formal verification of the rules that move value, and EternaX has published the full verification of its open-source Bitcoin vault. We walk the talk.
Definition
What is formal verification?
Formal verification is the use of mathematical proof, checked by a computer, to show that software satisfies a precise written specification for every possible input, not only the inputs someone tested.
In plain terms: you state exactly what the software must always do, and then you prove, step by step, that it does. The proof is not an opinion and not a sample. It is a chain of logical steps that a separate program, called a proof checker or kernel, verifies one by one. If any step is wrong, the check fails. If the check passes, the rule holds for every input the code can ever receive, within the stated assumptions.
Formal verification is the strictest member of a wider family called formal methods: mathematically rigorous techniques for specifying, designing and checking software and hardware.
"Lean proofs should never be believed until they have been checked by the kernel." Thomas Hales, who led the formal proof of the Kepler conjecture, writing on Terence Tao's blog, 9 October 2026
A worked example: one rule, one bug
Take one rule from a digital-asset vault: funds move only if at least three different approvers sign. Suppose the code counts valid signatures but never checks that they come from different approvers. Every test the team wrote uses three different people, so every test passes, and a reviewer reading quickly may miss it. A proof attempt fails at once, because the checker reasons about inputs the tests never tried, including one approver submitting the same valid signature three times. That counterexample is the bug. Fix the code, the proof goes through, and the rule now holds for every possible input.
One rule, one bug, three ways to look for it
The three main techniques
| Technique | How it works | Typical tools | Best for |
|---|---|---|---|
| Model checking | Exhaustively explores every reachable state of a finite model of the system | TLA+ with TLC, SPIN, NuSMV | Protocols, concurrency, distributed designs |
| Automated deductive verification | Turns code and specification into logical formulas and asks an SMT solver to prove them | Certora Prover, Dafny, Halmos, Kani, Verus, Solidity SMTChecker | Smart contracts, Rust and C components |
| Interactive proof assistants | People or AI write proofs step by step; a small kernel checks every step | Lean 4, Rocq (formerly Coq), Isabelle/HOL | Cryptography, compilers, kernels, mathematics |
Symbolic protocol verifiers such as Tamarin and ProVerif apply the same idea to cryptographic protocols, and were used to analyse TLS 1.3 and 5G authentication.
How it works, in four steps
- Specify. Write the rule precisely in a formal language, next to a plain-language version people can review.
- Connect the code. The proof tool reads the real code, or the code is translated into the tool's language. That translation must itself be trusted or checked.
- Prove. A person, an automated solver or an AI constructs the proof. Failed attempts produce counterexamples, which are bugs or mistakes in the rule.
- Check, and keep checking. The kernel verifies every step, and the proof is re-run on every code change, so "verified" stays true after the next release.
Vocabulary you will see in a verification report
Formal verification turns "we believe it is correct" into "here is the proof; check it yourself."
Proofs versus audits
Inspection samples. A proof covers everything in its box.
A security audit is skilled inspection. Experts read the code, follow the paths they judge most dangerous, and report findings. Good audits catch a great deal, and nothing on this page argues against them. But an audit's strongest possible conclusion is "we found nothing further." It cannot say "nothing further exists." Euler Finance had been audited by several firms before a missing health check cost roughly $197 million in March 2023. The reviewers sampled around the bug.
The same is true of tests, fuzzing and AI review. Each is a search, and however fast or wide, a search ends with a list of what it found. As Edsger Dijkstra put it in 1970, testing can show the presence of bugs, but never their absence.
Audit versus proof, same code
Two words in the definition carry the whole argument. Every input: a proof is exhaustive. The rule: a proof covers only what was written down. That is why formal verification is the strongest assurance available, and why its claims must be read carefully.
| Method | What it establishes | Coverage | Certainty | What it cannot tell you |
|---|---|---|---|---|
| Unit and integration tests | Chosen inputs behave as expected | Chosen cases | High, for those cases | Anything about untested inputs |
| Fuzzing | Random or guided inputs do not crash or violate checks | Millions of cases | Statistical | Whether a rare path exists |
| Manual audit | Experts found, or did not find, issues in scope | Wide, judgment-led | Expert confidence | Whether anything was missed |
| AI-assisted review | Known and novel bug patterns found across the codebase | Very wide, fast | Expert confidence, scaled | Absence of bugs |
| SOC 2 / ISAE 3402 | The company's controls operated over a period | Processes, not code | Independent attestation | Whether the code is correct |
| Formal verification | The code satisfies stated rules for all inputs | Only the stated rules and in-scope code | Mathematical | Anything outside the rules, the code, or the assumptions |
Formal verification is the only method with mathematical certainty, and the one with the narrowest reach. Vitalik Buterin describes where that trade-off pays off:
"...particularly well-suited for situations where the goal is much simpler than the implementation." Vitalik Buterin, co-founder of Ethereum, A shallow dive into formal verification, 18 May 2026. His examples: quantum-resistant signatures, STARKs, consensus algorithms and zkEVMs.
An audit tells you what experts found. A proof tells you what cannot happen. Aim proofs at the rules that move money.
Why it matters now
The world's money is moving through code
The world's listed stocks and bonds are worth about $318 trillion: $157.8 trillion in equities and $160.7 trillion in fixed income at the end of 2025, according to SIFMA. The flows on top of them are far larger. DTCC, the core post-trade infrastructure of US markets, processed securities transactions worth $4.7 quadrillion in 2025.
Those flows have started to run on blockchains and distributed ledgers. In August 2026, Broadridge's Distributed Ledger Repo settled $7.4 trillion of repo transactions, about $351 billion a day, using smart contracts to move tokenized securities and cash together. On 28 October 2026, DTCC launched its Tokenization Service on the Canton Network and its own private Besu network, with collateral mobility among its stated goals. The assets are mostly still off-chain. The money is already moving through on-chain code.
From billions to quadrillions: what exists, and what moves
Why blockchains change the requirement
Size alone does not demand proof: far more money moves through traditional systems whose code has never been formally verified. What changes on a blockchain is what the code is allowed to decide, and whether anyone can undo it.
Why blockchains need proofs, not just inspection
Every other assurance method quietly assumes a second chance. Testing assumes you tried the inputs that matter; monitoring assumes you can react in time; patching assumes you can fix things afterwards. On a blockchain, an exploit can complete within a single transaction, and settled value does not come back. Only a proof establishes, before the code runs, that a rule holds for every input an attacker could ever try.
This is the reasoning that put formal verification into flight control, railway signalling and chip design: wherever failure is catastrophic and cannot be undone, and the critical rules can be written down exactly, industries moved from inspection to proof. On-chain finance now meets every one of those conditions.
Why the pressure is rising
Software flaws are being found faster than ever, by defenders and attackers alike. 48,185 vulnerabilities were published in 2025, 21% more than in 2024, and FIRST's mid-year forecast projects around 66,000 for 2026, with AI accelerating the search on both sides.
Software vulnerabilities published per year
At the same time, the most sensitive code is being rewritten. NIST finalized its post-quantum standards in August 2024, and US Executive Order 14412 requires post-quantum key establishment by the end of 2030 and post-quantum digital signatures by the end of 2031. Every signature check that authorizes the movement of value will be replaced with new, larger cryptography, written under deadline, which is historically when the worst bugs enter: the 2008 Debian OpenSSL key flaw, Heartbleed in 2014, ROCA in 2017, timing leaks in early ML-KEM implementations in 2023 and 2024. Inspection missed all four. Three were implementation errors that a proof of the right property would have caught; ROCA was a design flaw, the kind a careful specification exists to prevent.
Three forces, one requirement
For the rules that move money, formal verification is the strongest assurance that exists, and the only one that covers every case. It does not replace key management, operational controls or audits; it secures the part of the system that, on these rails, nothing else can.
On these rails, the code is the custody agreement. It should be proven like one.
Why now
Proofs were a luxury. In 2026 they are a tool.
The idea is not new. Alan Turing argued in 1949 that programmers should attach assertions to a program so a checker could verify it piece by piece. Tony Hoare's logic of 1969 supplied the mathematics. Proof assistants arrived in the 1970s and 1980s. For fifty years the obstacle was never doubt about whether proofs worked. It was cost.
The seL4 operating-system kernel shows the price. Its 2009 proof covered about 8,700 lines of C with roughly 200,000 lines of proof script, around 20 person-years of work. At that price, proofs were reserved for aircraft, trains and chips: avionics standard DO-178C credits proofs in place of some testing, Paris Métro Line 14 was built with the B method, and Intel turned to formal methods after the 1994 Pentium division flaw cost it a $475 million charge. Everyone else inspected and hoped.
Two things changed, and they changed together: AI learned to write proofs, and the tools reached money-moving code.
"...formal verification is about to become vastly cheaper..." Martin Kleppmann, author of Designing Data-Intensive Applications, Prediction: AI will make formal verification go mainstream, 8 December 2025
From theory to baseline: 77 years in one line
AI writes the proof. A kernel checks it.
On 10 November 2026, Google DeepMind announced that AI agents had proven key security properties of the Signal protocol's production code, the cryptography that protects billions of private conversations, down to the compiled code running on devices. Human experts reviewed every specification, AI agents wrote the proofs, and Lean checked them. The work took four weeks, a task that historically took expert teams years. When the team reintroduced two real, previously fixed bugs, the system produced machine-checked proofs that the buggy versions were insecure. Google DeepMind says it is the first time the implementation of a widely deployed protocol like this has been formally verified by any method.
"We did it in a month's time." Pushmeet Kohli, Google DeepMind, announcing the Signal verification, 10 November 2026
The pattern is spreading. Runtime Verification's production pipeline lifts cryptographic Rust code into Lean and uses AI provers to close the proofs; in its authors' words, "Every proof is checked by the Lean kernel, so AI output cannot compromise soundness." In September 2026, Anthropic used AI agents to produce the first complete computer-checked proof of Fermat's Last Theorem in 11 days. Writing the proof, the expensive half, can now be delegated to a machine. Checking it, the half you trust, stays small, open and re-runnable by anyone.
The effect on trust is already visible. In November 2026, when an AI-assisted proof of the Aaronson-Ambainis conjecture was announced, the complexity theorist Scott Aaronson wrote that he believed it before he had understood it, for two reasons: "there's a Lean certificate," and independent human experts had already checked it. That is the new division of labour: machines check, humans review, and trust no longer depends on who wrote the proof.
The cost of a proof collapsed: seL4 in 2009, Signal in 2026
The tools reached money-moving code
Certora open-sourced its prover in February 2025 after years of use on DeFi protocols that it reports secured more than $100 billion in value. Kontrol, Halmos, Aeneas, hax and Verus turned smart-contract and Rust verification from research into engineering. The Ethereum Foundation made provable security the priority for its 2026 zkEVM roadmap, and Nethermind's verification team wrote in March 2026 that in a proof-driven Ethereum, formal verification becomes "a baseline requirement rather than a best practice."
Proof is no longer the expensive option. Being wrong is.
Where it fails
What a proof will not do for you
A proof covers a rule, over some code, under some assumptions. Everything outside those three things is exactly as unverified as it was before. This is the honest shape of a verified system.
The shape of a verified system
Lessons from real systems
The first two came from teams doing real, serious work, which is what makes them instructive.
In October 2025, a zero-knowledge virtual machine's developer announced, with a respected verification team, that the machine's entire core, 62 instructions, was formally verified against the official RISC-V specification. In May 2026 the Ethereum Foundation published its review: 51 of the 62 had complete, correct proofs. The one real bug sat inside an assumption the code itself admitted was unproven, and it was found by standard conformance tests, not by the proofs. The developer fixed it, and the Foundation drew the right conclusion: not to trust proofs less, but because many audiences treat formal verification as the final tool, to state exactly what has and has not been proven.
When "formally verified" was checked: 62 claimed instructions
Earlier in 2026, cryptographer Nadim Kobeissi documented 13 vulnerabilities across two formally verified cryptographic libraries used in production post-quantum deployments. By his account, nine were in code outside the verified boundary and four were inside the formal specifications and proofs themselves: a wrong constant, a missing transform, a false serialization proof, a wrong multiplication specification. He called the pattern verification theatre. The maintainers disputed parts of the characterization and fixed the issues. His remedy matches the Foundation's: publish the boundary and the assumptions, and let others attack the specification, not only the code.
And there is the oldest lesson, the one no proof touches. The roughly $1.5 billion Bybit theft in February 2025 exploited no contract flaw. Signers approved a transaction that differed from what their screens showed. A perfectly proven vault would have released the funds, because valid signatures satisfied its rules. Keys, people, hardware and displays are the real-world layer, and proofs do not reach it; clear-signing, hardware-side re-verification, time locks, policy limits and operational assurance do.
Selected losses, US$ millions, by root cause
The checker is software too
Everything above assumes the proof checker itself is right. It almost always is, but it is software. Lean's kernel is several thousand lines of C++, and in July and August 2026 security researchers using frontier AI found several soundness bugs in it: flaws that could let a false proof pass. One produced an illicit "disproof" of the Collatz conjecture. All were fixed quickly, and Lean's main mathematical library was re-verified with the repaired kernel, as Thomas Hales recounts in his October 2026 review.
The response is the discipline this guide recommends everywhere else: no single point of trust. About 25 independent Lean kernels now exist for cross-checking, and in September 2026 Joachim Breitner released a Lean checker with a formal consistency proof. For anyone relying on a proof, the practical rule is to re-check it with more than one independent checker, and to count the checker inside the trusted computing base, not outside it.
A proof is only as honest as the list of what it leaves out.
Reading a claim
Four questions for anyone who says "formally verified"
"Formally verified" is becoming a marketing phrase. Because the underlying evidence is precise, a precise claim is easy to check and a vague one is easy to spot. These four questions separate them.
- Which properties were proven? Expect a short list of exact rules in plain language, each with a formal counterpart. "The system is verified" is not an answer. "No transfer executes without a valid quorum over exactly this payload" is.
- Over which code, at which version? Expect a boundary: these modules, this commit, this compiler. Expect a candid list of what sits outside the boundary.
- Under which assumptions and axioms? Every proof has them. A trustworthy report lists each one and says how it is tested or justified.
- Can our team re-run the proof checker? This question keeps the other three honest. Proof files, specifications and pinned tool versions, provided under NDA if the code is private, let the buyer's own engineers reproduce the result, ideally with more than one independent checker.
Here is what a credible answer looks like in practice: a real, published verification statement.
A real verification statement: EternaX's open-source Bitcoin vault
Words to treat as warning signs.
"Bug-free." "Unhackable." "Mathematically guaranteed secure." "Formally audited." "AI-verified." Each either claims more than a proof can give or names something that is not a proof. The accurate form is narrow: these invariants, of this code, under these assumptions, with machine-checked proofs you can re-run.
One more test belongs to the buyer: are the proven rules the ones that matter? A proof that an interest calculation rounds correctly is real but minor. A proof that value cannot move without authorization is what a risk committee needs.
The four questions, on one card
A proof you cannot re-run is a claim. Ask for the four things, every time.
Where EternaX stands
We adopted formal verification because our products exist to answer one question for institutions: can value move without authorization? Only a proof answers that for every possible case. That is why every EternaX solution comes with formal verification of the rules that govern how value moves: the quorum of post-quantum approvals, limits, time locks, freeze, replay protection, key rotation and crypto-agility.
We walk the talk: proof, published
Open-source Bitcoin vault · formal verification published
We ask every vendor four questions. Here are our answers, in public, for our open-source Bitcoin vault reference implementation.
| What is proven | Only all of its signatures can spend the vault, for every key count from 1 to 201, plus five more properties: valid unlocks, an exact address, key recovery from the seed, conserved value, and no payment back to a spent vault. Read the report. |
|---|---|
| Which code | The open-source release, pinned to commit 0e624ed and checked against the signed Bitcoin Core v31.1 release. |
| Which assumptions | Stated in full in the published specification. |
| Can you re-run it | Yes. One script, verification/run_all.sh, with the results of the last full run published alongside it. |
The open-source release demonstrates one part of the design, and our method. The EternaX Bitcoin Vault product goes much further: post-quantum (SLH-DSA) approval quorums, enforcement inside the institution's HSM, attestation, and private relay for up to 201 keys. It is built and verified with the same discipline.
Our proofs are published for our open-source code, and delivered to the institutions that engage with us for our products, to run in their own environment. Either way, trust rests on a check your own team performs, not on our word.
- Post-quantum signatures: hash-based SLH-DSA (FIPS 205) by default, the most conservative NIST standard and the cleanest to specify against.
- EternaX never holds keys. Custody stays with the institution; the proofs govern authorization, not key storage.
Request a solution, receive its proofs
Choose the solution that fits your assets.
Post-quantum controls for issuance, compliance, permits, and governance.
Post-quantum secure vault for ETH, stablecoins and ERC-20s, signed by your existing HSMs.
Post-quantum security for Bitcoin custody on your existing HSM, with no fork.
Post-quantum institutional settlement infrastructure.
PQ-safe tokenization, privacy, custody, and consensus for Hyperledger Besu.
EternaX assists FINRA member firms, G-SIBs, custody providers and tokenization platforms. Quantum-safe Settlement at Market Speed.
Questions institutions ask
Frequently asked questions
Definitions
What is formal verification in simple terms?
Formal verification is the use of mathematical proof, checked by a computer, to show that software satisfies a precise written specification for every possible input, not only the inputs someone tested. Testing and audits try inputs and look for failures; a proof covers all inputs for the stated rule, and anyone with the proof files can re-run the checker.
What does "formally verified" actually mean?
It means specific, written properties of specific code have been proven with a machine-checked proof, under stated assumptions. It does not mean the whole product is proven or that it is bug-free. A credible claim names the properties, the code version, the assumptions, and provides proofs that can be re-run.
What is the difference between formal verification, formal methods and model checking?
Formal methods is the umbrella term for mathematically rigorous techniques in software engineering. Formal verification is the subset that proves code meets a specification. Model checking is one formal verification technique that exhaustively explores every state of a finite model; deductive verification with proof assistants such as Lean, Rocq or Isabelle is another.
What are the main types of formal verification?
The three main techniques are model checking, which exhaustively explores every state of a finite model; automated deductive verification, which uses SMT solvers to prove that code meets its specification (tools such as the Certora Prover, Dafny, Halmos, Kani and Verus); and interactive proof assistants such as Lean, Rocq and Isabelle, where proofs are written step by step and checked by a small kernel.
What is a specification or invariant in formal verification?
A specification is the precise written rule the code must satisfy. An invariant is a rule that must hold at all times, after every operation, for example "no funds leave the vault without a valid quorum of signatures." Most rules about moving money are invariants, which is why they are natural targets for proofs.
What is a proof assistant such as Lean?
Software in which proofs are written in a formal language and checked step by step by a small trusted core called the kernel. Lean 4, Rocq (formerly Coq) and Isabelle/HOL are the main ones. The kernel is the only part that has to be trusted; everything else, including AI that helps write proofs, is checked by it.
Comparisons
Is formal verification the same as a security audit?
No. An audit is expert inspection: reviewers search for bugs and report what they found. Formal verification is a machine-checked proof that code satisfies a written rule for every input. Audits are wide and probabilistic; proofs are narrow and certain. Serious teams use both.
How is formal verification different from testing and fuzzing?
Testing and fuzzing run the code on chosen or random inputs and report failures; they can only show the presence of bugs. Formal verification reasons about all inputs at once and shows that a stated rule cannot be violated. Fuzzing remains valuable for the properties nobody thought to specify.
Is an AI code review the same as formal verification?
No. AI review searches for bugs; formal verification proves their absence for stated properties. AI now helps write proofs, but a small trusted proof checker re-verifies every step, so the result is a proof regardless of who or what wrote it. A bug search without a checkable proof artifact is a review, however good it is.
Does formal verification replace SOC 2 or an external audit?
No. SOC 2 and ISAE 3402 assess a company's controls and processes over time. An external audit provides independent review by people with no stake in the outcome. Formal verification proves code properties. Institutions need all three. Proofs shrink audit scope and cost; they do not replace independence.
Does formal verification mean the code is bug-free?
No. A proof shows the code follows the specific rules that were written down, over the specific code that was proven, under stated assumptions. Bugs can remain in behavior nobody specified, in a rule that was itself wrong, in code outside the proof, and in the real-world layer: keys, people, hardware and what signers see on screen.
Cost, time and trust
How long does formal verification take?
It depends on scope. The seL4 kernel, about 8,700 lines of C, took around 20 person-years to prove in 2009. In 2026, AI provers close many proof obligations automatically, and a small set of smart-contract invariants can typically be specified and proven in weeks rather than years. Proving a cryptographic verifier against its standard is a larger, months-scale effort.
How much does formal verification cost?
Costs are not usually public and vary with scope. The main driver is engineering time to write specifications and proofs; AI provers and open-source tools such as the Certora Prover, Kontrol and Halmos have reduced it substantially since 2025. Narrow, well-chosen scopes are far cheaper than attempting to verify a whole product.
Can an entire product be formally verified?
In practice, no. Proofs are far longer than the code they cover, every rule must be written precisely, and user-facing code changes constantly. Even seL4 trusts its hardware and parts of its boot code. The effective pattern is a small proven core through which every sensitive operation must pass, surrounded by tested and reviewed code.
Why can a proof written by AI be trusted?
Because the AI only searches for the proof; a small, open proof checker verifies every step and rejects anything invalid. Runtime Verification's May 2026 pipeline states that every proof is checked by the Lean kernel, so AI output cannot compromise soundness. Trust rests on the checker and the specification, not on the AI, which is why important proofs are re-checked with independent checkers.
Has production cryptographic code ever been formally verified?
Yes, increasingly. Verified implementations of cryptographic building blocks such as HACL* and Fiat-Crypto have shipped in major browsers for years. In November 2026, Google DeepMind announced it had used AI agents to prove key security properties of the Signal protocol's production code, down to the compiled code on devices, in four weeks; it says this is the first time the implementation of a widely deployed protocol like this has been formally verified by any method.
Can the proof checker itself have bugs?
Yes. A proof checker is software, so a bug in it could let a false proof pass. In July and August 2026, security researchers using frontier AI found several such soundness bugs in Lean's kernel, including one that allowed an illicit disproof of the Collatz conjecture; all were fixed and Lean's main library was re-verified. The defence is to re-check important proofs with independent checkers: about 25 independent Lean kernels exist, and a Lean checker with a formal consistency proof was released in September 2026.
Blockchain and digital assets
Why do blockchains need formal verification?
Because on a blockchain there is no second chance. Settlement is designed to be final, the smart contract is the final authority over who can move value, the code is often public and callable around the clock, and attackers can combine contracts and borrowed capital in ways no tester anticipates. Testing, audits, monitoring and patching all assume a chance to fix things later. Formal verification is the only method that establishes, before the code runs, that the rules that move money hold for every possible input.
How much value moves through blockchain-based financial infrastructure?
Tokenized repo already settles trillions of dollars a month: Broadridge's Distributed Ledger Repo processed $7.4 trillion in August 2026. DTCC, which processed $4.7 quadrillion in securities transactions in 2025, launched its Tokenization Service on the Canton Network and its private Besu network on 28 October 2026. Tokenized real-world assets held on-chain were about $39 billion in November 2026, alongside roughly $285 billion in stablecoins.
Can smart contracts be formally verified?
Yes. Smart contracts are a strong fit because their critical rules are short and exact. Tools include the Certora Prover (open-sourced in February 2025), Kontrol and KEVM from Runtime Verification, Halmos, and Solidity's SMTChecker. Ethereum's deposit contract and major DeFi protocols have had properties formally verified.
Which DeFi protocols and blockchain projects use formal verification?
Certora reports its prover has been used on protocols including Aave, MakerDAO, Uniswap, Lido and Safe. Runtime Verification verified Ethereum's deposit contract and early Safe contracts. The Ethereum Foundation funds formal verification of zkEVMs and cryptographic components, and Move-based chains ship a built-in prover.
Is Ethereum using formal verification?
Yes, alongside audits, fuzzing, bug bounties and multiple independent implementations. The Ethereum Foundation made provable security its 2026 zkEVM priority, funds Lean libraries and verification of zkVMs, and in May 2026 published a detailed review of a zkVM's verification claims. Vitalik Buterin wrote in May 2026 that formal verification is especially suited to quantum-resistant signatures, STARKs, consensus algorithms and zkEVMs.
Which tools are used for formal verification in crypto?
For EVM contracts: Certora Prover, Kontrol/KEVM, Halmos and SMTChecker. For Rust: Aeneas and hax (to Lean or F*), Verus and Kani. For proof assistants: Lean 4, Rocq and Isabelle/HOL. AI provers such as Harmonic's Aristotle and Logical Intelligence's Aleph now assist within these pipelines.
Would formal verification have prevented hacks like The DAO or Euler?
Likely yes for those two. The DAO's reentrancy and Euler's missing health check each violated a rule short enough to state in one line, and a proof of that rule would have failed. Euler had passed multiple audits. Formal verification would not have prevented key-theft or phishing incidents such as Ronin or Bybit.
Post-quantum and regulation
Can post-quantum signature code be formally verified?
Yes, and it is a priority target. Verified implementations of ML-KEM and ML-DSA exist, Vitalik Buterin named quantum-resistant signatures as a prime formal-verification target in May 2026, and hash-based SLH-DSA (FIPS 205) is a clean target because its security rests only on hash functions. Correctness proofs must still be read carefully, as the 2026 "verification theatre" findings showed.
Why are hash-based signatures a good fit for formal verification?
SLH-DSA (FIPS 205) rests only on the security of hash functions, with no structured algebraic problem for new attacks, classical, quantum or AI-assisted, to target. It is the most conservative NIST post-quantum signature standard, and a verifier's correctness can be stated directly against the standard.
Do regulators require formal verification?
Not for financial software today. Formal methods are recognised in avionics (DO-178C with DO-333), rail (EN 50128) and Common Criteria EAL7, and the 2024 White House report on software security encourages them. Bank third-party risk rules such as the US interagency guidance and EU DORA are principles-based: they require demonstrable assurance, which proofs strengthen, but they do not mandate proofs.
How does Executive Order 14412 relate to formal verification?
EO 14412 (June 2026) sets US federal deadlines for post-quantum key establishment by the end of 2030 and post-quantum digital signatures by the end of 2031. It does not mention formal verification, but it forces a wave of new cryptographic code written on a deadline, which is historically when implementation bugs enter, and which is exactly where proofs add the most.
Evaluating a vendor
What should an institution ask when a vendor says "formally verified"?
Four questions: Which properties were proven? Over which code and version? Under which assumptions and axioms? Can our team re-run the proof checker? A vendor who cannot answer all four has not formally verified anything in the sense that matters.
What are warning signs of an overstated formal verification claim?
Phrases such as "bug-free," "unhackable," "mathematically guaranteed secure," "formally audited" or "AI-verified"; no list of proven properties; no stated assumptions; no way to re-run the proofs; and claims that cover "the whole system." The Ethereum Foundation's 2026 review of SP1 Hypercube and Kobeissi's "Verification Theatre" paper document what happens when claims outrun proofs.
Does formal verification stop attacks like Bybit?
No. The roughly $1.5 billion Bybit theft in February 2025 did not exploit a contract bug; signers approved a transaction that differed from what they saw. Proofs cover code logic. Compromised signer machines and phished approvals require clear-signing, hardware-side re-verification of what is being approved, time locks and policy limits.
EternaX
Do EternaX solutions come with formal verification?
Yes. Every EternaX solution comes with formal verification of the rules that govern how value moves. For EternaX products, proofs, specifications and assumptions are delivered to the institutions that engage with EternaX, to run in their own environment; for EternaX's open-source Bitcoin vault, the full verification is published. EternaX uses hash-based SLH-DSA (FIPS 205) as its post-quantum primitive and never holds keys. See the solutions in "Where EternaX stands," above.
Has EternaX published its formal verification?
Yes. For its open-source Bitcoin vault reference implementation, EternaX has published the specification, the Z3 proofs, the verification report and a script that re-runs every check: for every key count from 1 to 201, the vault can be spent only with all of its signatures. The EternaX Bitcoin Vault product goes further and is verified with the same discipline; proofs for EternaX products are delivered to the institutions that engage with EternaX. Read the published verification.
Explore EternaX solutions → Each is delivered with its formal verification proofs.