The quietest crises in crypto are the ones that happen before the code is written. I remember a cold January evening in 2018, staring at a Solidity contract for a lottery game that had just raised $3 million in a presale. The developer had used block.timestamp and blockhash as the sole source of randomness, proudly declaring it "provably fair." It wasn't. I flagged it in my audit, and the project dissolved. The silence in the ledger after that correction was louder than any code—it was a warning that too few developers hear. That silence is what I want to talk about today: the fundamental inability of deterministic blockchains to produce true randomness, and the danger of assuming otherwise.
Context: The Cryptographic Imperative
We are building on a machine that executes instructions with unwavering determinism. Every node in a blockchain network runs the same code, processes the same transactions, and arrives at the same state. In such an environment, a call to Math.random() is not random—it is a predictable function of the current state, which any miner or validator can compute. The Ethereum Virtual Machine, like all deterministic environments, cannot produce genuine entropy. This is not a bug; it is a feature of the consensus model. But when a developer needs to assign a rare NFT, pick a winner in a raffle, or shuffle a deck in a game, they must find entropy elsewhere. The answer lies in cryptographic primitives: Verifiable Random Functions (VRF), RANDAO, commit-reveal schemes, and even the prevrandao opcode introduced in the Ethereum Merge. These methods do not create randomness from nothing—they create verifiable randomness, ensuring that the output is both unpredictable before the fact and provably correct after the fact.
Understanding this distinction is not merely academic; it is the difference between a thriving ecosystem and a series of costly exploits. The 2021 Polygon Hermez exploit, the 2022 Wintermute hack, and countless smaller incidents all trace back to flawed randomness assumptions. The article that inspired this analysis—a Crypto Briefing piece on the basics of blockchain randomness—does a service by reminding readers that "blockchain cannot use ordinary random number generators." But it stops there. It whispers the problem but does not shout the solution. As someone who has spent years auditing contracts and building governance systems, I feel the weight of that silence. The code is not enough; we need to weave conviction into our random choices.
Core: The Technical Reality and the Hidden Assumptions
Let me be specific. The cryptographic methods available today fall into two broad categories: on-chain, multi-party entropy sources (like RANDAO) and off-chain, verifiable sources (like Chainlink VRF). RANDAO, used in Ethereum's beacon chain, relies on a set of validators committing to a secret value and then revealing it. The final random value is the XOR of all revealed secrets. This is elegant but assumes that at least one honest participant remains in the set. If a colluding majority can manipulate the last reveal, they can bias the outcome. That is a real assumption, and it is often overlooked in educational material. Chainlink VRF, on the other hand, uses a cryptographic key pair: the oracle generates a random number and a proof that is verified on-chain. The assumption here is that the oracle is trusted not to collude with the requester or to be compromised. Neither assumption is trivial.
I recall a workshop I facilitated in 2020 for a DAO that was building a random selection mechanism for treasury grants. The developers proudly showed me their VRF integration, but they had not considered the economic incentive for the oracle node to front-run the reveal. The silence in the ledger was not about code—it was about the trust assumptions baked into the architecture. We rewrote the process to use a hybrid approach: a commit-reveal across multiple independent nodes, with a fallback to blockhash. It was not perfect, but it was honest about its limitations. That honesty is what I believe the industry needs more of. We do not write code; we weave conviction. And conviction requires transparency.
The fallacy of the 'perfect' random number
Another common mistake is assuming that any cryptographic random number is 'good enough' for all applications. Consider a high-stakes lottery where the payout is $10 million. Even a 0.0001% bias from a VRF implementation could be exploited by a sophisticated attacker using statistical analysis over many rounds. The cost of verifying the bias is tiny compared to the potential reward. The Ethereum ecosystem learned this with the infamous 'RNG bug' in the 2018 Fomo3D game, where the attacker could calculate the winner based on transaction ordering. The problem was not the randomness source but the failure to account for the manipulative power of the transaction order. The silence in the ledger spoke louder than the code that day.
Based on my audit experience, I have seen three recurring failure modes: (1) using a single source of randomness without a tie-breaking mechanism, (2) exposing the random request too early in the transaction flow, allowing miners to reorder, and (3) assuming that the random number is truly uniform when the cryptographic construction may have subtle biases. These are not just technical details; they are ethical considerations. A project that launches a game with a flawed randomness scheme is not just making a technical mistake—it is breaking a social covenant with its users. Open source is not a license; it is a covenant. And that covenant demands that we test our assumptions, not just our code.
Contrarian: The Real Problem Is Not Technical—It Is Cultural
Here is where I diverge from the typical narrative. Most articles—including the one we are analyzing—focus on the technical solution: use VRF, use RANDAO, don't use blockhash. But the deeper issue is that the crypto culture has normalized a 'move fast and launch' mentality that treats randomness as a checklist item rather than a foundational trust layer. The educational article is a step in the right direction, but it risks creating a false sense of security. Developers read it, think 'I know I need verifiable randomness,' integrate a Chainlink VRF, and move on. They do not pause to ask: What are the economic assumptions? Who controls the oracle? What happens if the randomness request fails? The silence in the ledger is not the lack of code—it is the lack of rigorous questioning.
I have seen this firsthand. In 2022, after the Luna collapse, I spent months analyzing the failure modes of algorithmic stablecoins. The randomness of the seigniorage distribution was not even the worst problem, but it was symptomatic of a deeper issue: the entire system was built on untested assumptions about human behavior and market rationality. The silence in the ledger was the absence of a proper failure mode analysis. We need to apply the same rigor to randomness. The contrarian angle is this: verifiable randomness is not a panacea. It is a tool that comes with its own risk surface. The real innovation is not in the cryptographic algorithm but in the culture of verification that surrounds it. Nurture the niche of thorough security analysis, and the forest of healthy dApps will follow.
Takeaway: A Call to Build with Conviction
So what do we do? First, we must stop treating educational articles as engineering specifications. The Crypto Briefing piece is valuable for raising awareness, but it is only the beginning. Every developer who reads it should then go to the source code, read the VRF implementation, and understand the trust assumptions. Second, we need to build better tooling for testing randomness assumptions. I am working on an open-source framework called 'Veritas' that allows developers to simulate adversarial conditions on their randomness source. But that is just one project. The community needs a shared library of attack vectors and mitigation strategies. Open source is not a license; it is a covenant. And that covenant demands that we share our failures as openly as our successes.
Finally, I want to leave you with a question: When you look at the next NFT mint or GameFi launch, ask yourself—what is the silence in the ledger telling you? Is it the quiet confidence of a well-tested randomness scheme, or the ominous silence of an assumption that will be exploited? The void between tokens holds the true value. Fill it with conviction, not just code. Listen to what the repository refuses to say.