A Verifiable Delay Function (VDF) is a cryptographic primitive that guarantees a computation requires a specific, non-parallelizable amount of sequential time to complete, and whose output can be efficiently verified by anyone. This unique property of sequentiality—meaning the work cannot be sped up by adding more processors—makes VDFs fundamentally different from proof-of-work puzzles, which are parallelizable. The core components are a delay function that imposes the time delay and a verification algorithm that allows anyone to check the result's correctness almost instantly, without redoing the work. This creates a trustworthy source of time in decentralized systems.
LABS
Glossary
Verifiable Delay Function
A Verifiable Delay Function (VDF) is a cryptographic function that guarantees a computation requires a specific, non-parallelizable time to complete, and produces a proof that can be verified much faster.
Chainscore © 2026
definition
CRYPTOGRAPHIC PRIMITIVE
What is a Verifiable Delay Function?
A Verifiable Delay Function (VDF) is a cryptographic primitive that guarantees a computation requires a specific, non-parallelizable amount of sequential time to complete, and whose output can be efficiently verified by anyone.
VDFs are constructed using inherently sequential mathematical problems, most commonly repeated squaring in a group of unknown order, such as an RSA group or a class group. The prover must perform a long chain of sequential squarings, which cannot be parallelized, to generate the output and a proof. The verifier, using the proof and the public parameters, can then check the result's validity with a small, fixed amount of computation. This asymmetry—slow to compute, fast to verify—is the cornerstone of their utility. Prominent implementations include Chia Network's use of VDFs in its proof-of-space-and-time consensus and Ethereum's planned integration for randomness generation.
The primary applications of VDFs in blockchain and distributed systems are in random beacon generation and consensus mechanisms. For randomness, a VDF can create a unbiased, unpredictable random number that is resistant to manipulation, as any attempt to bias the output would require predicting the result of a long sequential computation. In consensus, VDFs can enforce waiting periods between block proposals, preventing grinding attacks and ensuring fair leader election, especially when combined with other resources like proof-of-stake or proof-of-space. This makes them a critical tool for enhancing security and fairness in decentralized protocols where a trusted source of time is absent.
key-features
COMPUTATIONAL PROPERTIES
Key Features of VDFs
Verifiable Delay Functions (VDFs) are cryptographic primitives defined by three core properties that enable secure, trust-minimized sequencing and timing in decentralized systems.
01
Sequential Computation
A VDF requires a precise, wall-clock time to compute, determined by a publicly known number of sequential steps. This inherent delay cannot be sped up by parallel processing or additional hardware, making it a reliable source of time in a trustless environment. This property is crucial for applications like proof-of-space blockchains (e.g., Chia) to create fair leader election.
02
Efficient Verifiability
While computing the VDF output is slow, anyone can verify the correctness of the result almost instantly. This asymmetry is fundamental: a prover spends significant time to generate a proof, while any verifier can check it with minimal computational effort. Verification typically involves checking a succinct proof against the public input and the claimed output.
03
Uniqueness & Soundness
For a given input, a VDF guarantees there is exactly one valid output. A malicious prover cannot find a different output that also passes verification. This property, also called soundness, ensures the function's result is deterministic and tamper-proof, preventing equivocation or manipulation of the delayed result.
04
Random Beacon Applications
VDFs are a core component for generating unbiasable randomness (random beacons) in blockchains. By applying a VDF to a high-entropy but potentially manipulable seed (e.g., a block hash), the required delay prevents the last revealer from predicting or influencing the final random output before it's published.
05
Construction: Wesolowski & Pietrzak
The two main practical VDF constructions are:
- Wesolowski VDF: Produces a very short, constant-sized proof, ideal for blockchain consensus where proof size is critical.
- Pietrzak VDF: Generates longer proofs that are simpler to verify, often used in settings where verifier simplicity is paramount. Both rely on repeated sequential squaring in a group of unknown order.
06
Contrast with Proof-of-Work
VDFs are often contrasted with Proof-of-Work (PoW):
- Energy Use: PoW is massively parallel and energy-intensive; VDF computation is sequential and minimally energy-wasteful.
- Goal: PoW secures against Sybil attacks via cost. VDF provides a verifiable time delay, not security through cost.
- They can be complementary, as seen in Ethereum's RANDAO/VDF hybrid design for the beacon chain randomness.
how-it-works
CRYPTOGRAPHIC PRIMITIVE
How Does a Verifiable Delay Function Work?
A technical breakdown of the sequential computation and proof generation that enables trustless time delays in decentralized systems.
A Verifiable Delay Function (VDF) is a cryptographic primitive that guarantees a computation requires a specific, non-parallelizable amount of sequential work to complete, yet produces a unique output that can be verified quickly by anyone. This creates a provable, "wall-clock" time delay. The function is defined by three algorithms: Setup, which generates public parameters; Eval, which performs the slow, sequential computation to produce the output and a proof; and Verify, which allows anyone to instantly check the output's correctness against the proof and the original input.
The core mechanism relies on inherently sequential mathematical operations, most commonly repeated squaring in a group of unknown order, such as an RSA group or a class group. Given an input x and a delay parameter T, the evaluator must compute y = x^(2^T) mod N, where N is a large composite number whose factorization is unknown. This exponentiation chain cannot be sped up by adding more parallel processors, enforcing a real-time delay. The evaluator also generates a succinct proof, often using Wesolowski or Pietrzak protocols, to demonstrate that y was computed correctly without redoing the work.
Verification is efficient and does not scale with the delay parameter T. Using the proof, a verifier can check the result in logarithmic time (or even constant time with some schemes), confirming both that the output is correct and that the prescribed sequential steps were honored. This property is crucial for preventing grinding attacks and ensuring fairness in protocols where timing is critical, such as leader election in consensus or randomness generation. The security of a VDF depends on the algebraic assumptions of the underlying group, particularly the difficulty of factoring N or computing discrete logs.
examples
APPLICATIONS
Real-World VDF Examples & Use Cases
Verifiable Delay Functions (VDFs) provide a unique cryptographic primitive for generating trustless randomness and coordinating time in decentralized systems. Here are their primary applications.
03
Delay-Based Proof-of-Replication (Filecoin)
Filecoin's Proof-of-Replication (PoRep) originally incorporated a VDF-based Seal operation. The VDF enforced a mandatory, verifiable time delay during the process of encoding storage data, proving that a miner was dedicating real storage space and computation over time, rather than cheating by generating proofs on-demand. This made the cost of generating a proof align with the cost of storing the data.
04
Non-Interactive Timelock Puzzles
VDFs enable non-interactive timelock puzzles, where a secret can be encrypted so that it can only be decrypted after a specific, verifiable amount of sequential computation has been performed. This has applications in:
- Sealed-bid auctions: Revealing bids after a fixed delay.
- Key escrow: Recovering keys after a set time period.
- Vesting schedules: Programmatically releasing funds without a trusted third party.
05
Randomness for Gaming & NFTs
On-chain gaming and NFT projects require provably fair randomness for loot boxes, matchmaking, or trait generation. A VDF-based randomness beacon provides a solution that is:
- Unpredictable: The output cannot be known before the delay elapses.
- Bias-resistant: Miners/validators cannot influence the result.
- Verifiable: Anyone can cheaply verify the correctness of the random output after the fact, ensuring transparency and fairness.
06
Resource Pricing & Anti-Spam
VDFs can be used to implement proofs of sequential work for rate-limiting and anti-spam mechanisms. By requiring a message sender to compute a VDF, the protocol imposes a mandatory, non-parallelizable time cost for actions like creating new identities or submitting transactions. This creates a sybil-resistant gate that is fair (cost is time, not hardware) and verifiable, preventing spam without relying on transaction fees alone.
ecosystem-usage
APPLICATIONS
Ecosystem Usage: Who Uses VDFs?
Verifiable Delay Functions (VDFs) are a cryptographic primitive that enforces a minimum, non-parallelizable computation time, creating a reliable source of time in decentralized systems. Their unique properties make them critical for specific consensus mechanisms, randomness generation, and security protocols.
02
Randomness Beacons (Randao)
VDFs are a core component of publicly verifiable randomness beacons, which generate unpredictable random numbers for smart contracts and protocols. A common design, like Randao, uses a commit-reveal scheme where the final random output is the hash of all participants' reveals. A VDF is applied to this hash before publication, preventing the last revealer from manipulating the result by withholding their submission, as they cannot compute the final output faster than anyone else. This creates manipulation-resistant randomness for lotteries, gaming, and protocol upgrades.
05
Non-Interactive Proofs of Work
VDFs can function as a non-interactive and energy-efficient alternative to traditional Proof of Work (PoW). Instead of burning electricity on parallelizable hash puzzles, a VDF-based proof requires a specific, unavoidable elapsed time of computation. This can be used for anti-spam mechanisms, rate limiting, or client puzzles where the goal is to prove that a real-world time interval has passed, not that immense computational power was expended. This is sometimes called Proof-of-Ellapsed-Time (PoET).
06
Cryptographic Protocol Security
VDFs enhance the security of various cryptographic protocols by adding a timed-release or delay-enforced component. Key applications include:
- Preventing Front-Running: In blockchain transaction markets, a VDF can delay the processing of transactions to reduce the advantage of automated bots.
- Secure Multi-Party Computation (MPC): Enforcing a delay before output can be computed, preventing rushing attacks.
- Time-Lock Puzzles & Encryption: Creating messages or values that can only be decrypted or accessed after a specific, verifiable amount of time has passed.
COMPARISON
VDF vs. Proof of Work (PoW) vs. Hashing
A technical comparison of Verifiable Delay Functions (VDFs), Proof of Work (PoW), and standard cryptographic hashing functions.
| Feature / Property | Verifiable Delay Function (VDF) | Proof of Work (PoW) | Cryptographic Hash Function |
|---|---|---|---|
Primary Purpose | Impose a mandatory, verifiable time delay | Secure a network via competitive computation | Produce a deterministic, fixed-size output from input data |
Parallelization Resistance | |||
Energy Consumption | Low (single CPU core) | Extremely High (massive ASIC farms) | Negligible (instantaneous) |
Output Verifiability | Fast verification (< 1 sec) | Fast verification (< 1 sec) | Fast verification (< 1 sec) |
Computational Model | Inherently sequential (iterative squaring) | Embarrassingly parallel (hash trials) | Deterministic one-way function |
Use Case Example | Random beacon generation, leader election | Bitcoin, Ethereum 1.0 block mining | Data integrity checks, commitment schemes |
Security Basis | Inherent sequentiality of computation | Cost of hardware and electricity (economic) | Pre-image resistance, collision resistance |
security-considerations
VERIFIABLE DELAY FUNCTION
Security Considerations & Challenges
While Verifiable Delay Functions (VDFs) are designed to be secure, their implementation and integration into blockchain systems introduce specific challenges that must be carefully managed.
01
Trusted Setup & Parameter Generation
A critical security requirement for many VDF constructions is a trusted setup to generate public parameters. If this process is compromised, an attacker could create a 'trapdoor' to compute the VDF output faster than the prescribed delay, breaking the fundamental security guarantee. This necessitates complex multi-party computation (MPC) ceremonies, which are themselves a significant operational security challenge.
02
Hardware Acceleration & Parallelism
The security of a VDF relies on the inherent sequential nature of the computation. A primary attack vector is using specialized hardware (ASICs, FPGAs) or massive parallelism to speed up evaluation. A secure VDF must be inherently sequential, meaning that using more parallel processors does not significantly reduce the wall-clock time, ensuring the delay is enforced in practice.
03
Verification Cost & DoS Attacks
A core property of VDFs is that verification of the proof is fast and efficient. If verification is too computationally expensive, it opens the system to Denial-of-Service (DoS) attacks where malicious actors flood the network with invalid proofs that are costly to check. The succinctness of the proof is therefore a direct security consideration for network liveness.
04
Random Beacon Manipulation
In applications like Proof-of-Stake randomness generation, the VDF's input is a seed from a random beacon. If an adversary can predict or manipulate this seed (e.g., through a grinding attack), they can pre-compute potential VDF outputs offline. This breaks the unpredictability of the final output, requiring the beacon itself to be unbiasable and unpredictable.
05
Implementation Bugs & Side-Channels
Like any cryptographic primitive, bugs in the VDF's software implementation can be catastrophic. Vulnerabilities could allow for faster computation or forged proofs. Furthermore, side-channel attacks (timing, power analysis) on the hardware running the VDF evaluator could leak information, potentially weakening security. Rigorous auditing and constant-time implementations are essential.
06
Long-Term Cryptographic Assumptions
VDFs are built on specific computational hardness assumptions, such as the sequentiality of repeated squaring in a group of unknown order. The long-term security of the system depends on these assumptions holding against future advances in algorithms and quantum computing. Cryptographic agility—the ability to migrate to new VDF constructions—is a forward-looking security consideration.
DEBUNKING MYTHS
Common Misconceptions About VDFs
Verifiable Delay Functions (VDFs) are a critical cryptographic primitive, but their unique properties often lead to confusion with other concepts like Proof of Work or general-purpose computation.
No, a Verifiable Delay Function (VDF) is fundamentally different from Proof of Work (PoW). While both require sequential computation, a VDF's output is uniquely determined by its input, and the computation cannot be parallelized. In contrast, PoW is a probabilistic race where miners search for a valid nonce, a task that is highly parallelizable. The key distinction is that VDFs guarantee a minimum elapsed time for computation, whereas PoW's time-to-solution is variable and depends on total network hashrate. This makes VDFs suitable for applications requiring unbiased, time-based randomness or proof of elapsed time, not competitive mining.
VERIFIABLE DELAY FUNCTIONS
Technical Deep Dive
Verifiable Delay Functions (VDFs) are cryptographic primitives that enforce a minimum, non-parallelizable computation time, creating a unique form of trustless time in decentralized systems. This section explores their mechanics, applications, and role in blockchain consensus.
A Verifiable Delay Function (VDF) is a cryptographic function that guarantees a minimum, non-parallelizable computation time, producing a unique output that can be verified much faster than it was generated. This creates a reliable, trustless source of time for decentralized systems. Unlike Proof-of-Work, which relies on probabilistic parallelism, a VDF's delay is sequential and deterministic, enforced by inherent computational steps like repeated squaring in a finite group. The output is accompanied by a succinct proof, allowing anyone to verify its correctness almost instantly. This property is crucial for applications like random beacon generation and leader election in consensus protocols, where unbiased, unpredictable results are needed.
VERIFIABLE DELAY FUNCTION
Frequently Asked Questions (FAQ)
A Verifiable Delay Function (VDF) is a cryptographic primitive that enforces a minimum, non-parallelizable computation time, whose result can be verified quickly. This section addresses common technical questions about its role in blockchain consensus and security.
A Verifiable Delay Function (VDF) is a cryptographic function that requires a prescribed minimum number of sequential computational steps to evaluate, but whose output can be verified as correct almost instantly. This creates a provable time delay that cannot be sped up by parallel processing or specialized hardware. VDFs are crucial for creating unbiased, unpredictable randomness and ensuring fair leader election in proof-of-stake blockchains, as they prevent an adversary from computing the result ahead of time and manipulating the outcome.
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall