Research
Catching the Fly: Practical Challenges in Making Blockchain FlyClient Real
FlyClient lets a resource-constrained device verify an entire PoW blockchain by sampling a logarithmic number of block headers, rather than downloading everything or trusting a third-party node.

- arXiv
- 2604.26736
- Published
- 2026-04-29
- Authors
- Pericle Perazzo, Dario Capecchi
AI summary
Overview
- Research area: Lightweight verification of Proof-of-Work blockchains, specifically the FlyClient super-light client protocol, with an implementation focus on Zcash.
- Technical level: Advanced. The paper combines formal adversary modelling, security reductions and numerical optimization with a systems-level engineering effort on a production full node, so readers need prior familiarity with Merkle trees, PoW consensus and security-parameter reasoning.
- Scope in one sentence: The paper bridges FlyClient's theory-to-deployment gap by introducing an economically interpretable adversary model, building the first FlyClient prover for Zcash inside Zebrad, and evaluating two proof-size optimizations.
What This Paper Is About
FlyClient lets a resource-constrained device verify an entire PoW blockchain by sampling a logarithmic number of block headers, rather than downloading everything or trusting a third-party node. Although Zcash natively integrated FlyClient through ZIP 221 in the Heartwood network upgrade, no prover implementation had been developed and the protocol remained experimental with few real deployments and little performance data under diverse conditions. This paper attacks that gap head-on: it makes the verifier easier to parameterize for real deployments, builds and measures an actual prover, and shrinks the proofs.
Key Contributions
- A new adversary model. The authors formally introduce the (w_a)-adversary, an alternative to the original ((c,L))-adversary, based on a single parameter — the adversarial work budget — that maps directly to the attacker's expected monetary budget. They prove (Lemma IV.1 and Theorem IV.1) that a (w_a)-adversary is automatically covered by a whole family of ((c,L)) assumptions, so the ((c,L)) pair becomes a free tuning knob for the verifier.
- A configuration method for the verifier. Given a (w_a) budget, the verifier's parameters are chosen by minimizing the total number of sampled headers ((n_{det} + n_{prob})), which requires numerically solving first-order conditions with no closed-form solution.
- The first practical FlyClient prover for a production blockchain. The authors extend Zebrad, the Rust-based official Zcash full node, with prover RPCs (including three new ones:
getHistoryNode,getAuthDataRoot,getTotalWork, plusgetHeightWithTotalWork), and estimate the extra resources required. Some extensions have already been accepted into the official Zebrad repository, and the code is published to the Zcash community. - Two proof-size optimizations. Cumulative proofs reduce non-interactive proof size by 9.16% and require no consensus change, so they are deployable at zero cost; distilled proofs reduce it by 71.33% but need a consensus-layer change.
Main Findings
- Concrete budget interpretation: Using an estimated cost of about 20,000 USD to mount a 51% attack on Zcash for one hour, 48 blocks produced per hour by the honest network, a (w_a) of 45,000 GH and an average block difficulty of 900 GH, the expected adversarial budget comes to 20,833 USD. The authors flag this estimate as potentially optimistic, because the attacker may get lucky and because older blocks may be cheaper to produce.
- Proof-size saving from the new model: For a 3-million-block chain, (\lambda = 50), and an adversarial block budget (n_a = c \cdot L = 50) blocks, a traditional configuration of (c=0.5), (L=100) yields 598 samplings (interactive) and 802 (non-interactive). The (w_a)-based optimum is ((c^=0.25, L^=200)) interactively with 423 samplings, and ((c^=0.2161, L^=231)) non-interactively with 504 samplings — a 37% saving in the non-interactive case.
- Bytes saved, header-only estimate: At 1,487 bytes per Zcash header, this moves the interactive download from 598 × 1,487 = 0.848 MiB to 423 × 1,487 = 0.600 MiB (−29%), and the non-interactive one from 802 × 1,487 = 1.137 MiB to 504 × 1,487 = 0.715 MiB (−37%). MMR nodes are excluded from this particular calculation but are said to grow roughly linearly with samplings.
- No apparent added security risk: An attacker who can produce a fork shorter than 100 blocks with 0.5 validity ratio lacks the budget to violate the ((0.25, 200)) or ((0.2161, 231)) assumptions, so the re-parameterized verifier still defends against such adversaries.
- Prover overhead is negligible during sync: A full sync of a FlyClient-capable Zebrad is comparable to a legacy instance, because generating and writing MMR nodes adds negligible execution time — the nodes already had to be computed to keep the tip header's HistoryTree current.
- Database upgrade costs about 10 hours: Converting an existing legacy database takes roughly 10 hours for a chain of about 3 million blocks, versus almost 40 hours for a full sync.
- Spam-attack artifact: The upgrade-time curve spikes around 1.5 million blocks due to a 2022 Zcash spam attack that greatly enlarged the chain; larger blocks mean longer database read times during that window. Outside that window, upgrade time and full sync time both grow linearly with chain length.
- Multi-MMR design in Zcash: The MMR does not grow indefinitely; it reboots at each network upgrade (Canopy in November 2020, NU5 in 2022, NU6 in 2024, NU6.1 in November 2025), with the first header of each consensus branch connecting old and new MMRs.
- Chain-sewing immunity: Because Zcash adopted FlyClient via a hard fork rather than a velvet fork, every block must carry valid FlyClient data, so the chain-sewing attack explored by Nemoz and Zamyatin does not apply to this prover.
- Size details: A Zcash MMR node is between 212 and 244 bytes; a header carries a 32-byte
hashBlockCommitments, 4-bytenTime, 4-bytenBits, 32-bytenNonce, a 3-bytesolutionSizealways equal to 1344, and a 1344-byte Equihashsolution.
Methodology in Plain English
The authors start from a complaint about the original security model: asking a deployer to specify "the longest fork (L) and its validity ratio (c)" is mathematically tidy but practically meaningless, since nobody knows how a real attacker maps onto those two numbers. So they replace it with one number — how much cumulative work an attacker can afford — and then show, with a formal lemma and a theorem, that defending against that attacker is equivalent to defending against a whole family of ((c,L)) assumptions. Because the ((c,L)) pair is now a free choice, they pick the pair that minimizes the number of sampled headers, which turns into a derivative-and-solve exercise with no closed-form answer, so they solve it numerically and plot the optimum.
For the engineering half, they take Zebrad and add the RPC calls a prover needs, keeping all protocol logic on the verifier side so the prover only answers requests. They then run three timing experiments on the same high-bandwidth virtual machine: a full sync with legacy Zebrad, a full sync with the modified node, and a database upgrade of an already-synced legacy node. Finally, they write a reference verifier in pseudo-code that caches downloaded headers and MMR nodes, handles the network-upgrade boundaries by walking back to the last upgrade height before the tip, and samples block heights according to the Bünz et al. work distribution when difficulty varies.
Why This Matters
For research, the paper supplies a reusable bridge between abstract adversary assumptions and deployment parameters — a pattern that extends beyond FlyClient to any protocol whose security is stated in terms of fork length.
Real-world applications the paper identifies:
- Mobile wallets: verify transaction presence without trusting a third-party full node.
- Internet of Things: resource-constrained devices performing machine-to-machine transactions or reading and writing immutable logs.
- Blockchain bridges: a smart contract validates a non-interactive FlyClient proof to check a foreign chain's state, enabling trustless bridges instead of trusted federations, provided the contract language can access the most recent block hash.
- Cross-chain smart-contract settings generally, as in the SmartFly line of work, though the Zcash-based approach here avoids SmartFly's recurring monetary cost because FlyClient is native.
For industry, the concrete artifacts matter: a working open-source prover for one of the most capitalized FlyClient-native cryptocurrencies, a measured deployment cost (about 10 hours of upgrade, negligible sync penalty), and a zero-consensus-change optimization worth 9.16% of non-interactive proof size that operators can adopt immediately.
Future Directions
- SNARK compression of FlyClient proofs. The authors explicitly note that non-interactive FlyClient proofs could in principle be compressed with SNARK techniques and state they plan to explore this, which would combine FlyClient's cheap prover side with SNARK verification's cheap verifier side.
- Deploying distilled proofs. The 71.33% saving is locked behind a consensus change, leaving open the question of how such a change would be standardized and rolled out across Zcash's network-upgrade cadence.
- Extending the (w_a) parametrization to other PoW chains. The paper gives a general budget formula but only instantiates it with Zcash figures, so the empirical fit for other chains is not reported.
- Tightening the cost estimate. The authors themselves flag that the 20,833 USD figure is an expected value, not a hard bound, and suggest using the cost of an average block from genesis to tip to counter the assumption that older blocks are cheaper to mine.
Target Audience
Protocol engineers and maintainers of full node implementations who want to ship light-client support; blockchain security researchers working on adversary modelling and light-client proofs; cross-chain bridge and wallet developers evaluating whether to trust FlyClient proofs; and graduate students in cryptography and security who want a worked example of turning a formal light-client result into a deployable system.
Authors’ abstract
FlyClient is a lightweight blockchain verification protocol that enables proof-of-work validation using minimal data, making it ideal for resource-constrained environments like mobile wallets, Internet-of-Things devices or cross-chain bridges implemented with smart contracts. Despite its strong potential for enabling lightweight blockchain verification, FlyClient protocol is still in the experimental stages, with limited real-world deployments and performance evaluations…
The full abstract on arXiv