Loading...
Supporting developers, startups, and full-fledged companies building on Stellar and Soroban
© 2025 Stellar Development Foundation
Subscribe to the Newsletter
By NebulaVRF
NebulaVRF provides developers with a fully on-chain VRF for Soroban, ensuring secure, verifiable randomness without external oracles.
NebulaVRF is a Verifiable Random Function (VRF) for Soroban, providing secure, unbiased, and cryptographically verifiable randomness for decentralized applications. It eliminates reliance on centralized randomness sources, ensuring tamper-proof and trustless randomness.
Ensuring pure randomness is critical in decentralized systems because predictable randomness leads to manipulation and exploits. A well-known issue is the last-mover attack (vector bias), where the final participant in a randomness-based event—such as a lottery or validator selection—can delay or withhold their commitment until they see a favorable outcome. This exploit allows malicious actors to influence supposedly fair processes by selectively participating only when the randomness favors them. Without a cryptographic guarantee, many existing blockchain randomness implementations remain vulnerable to such attacks, making them unsuitable for high-stakes applications like DeFi, governance, gaming, and secure voting.
Our current (tentative) approach being the VRF is, the VRF function generates randomness by taking a seed (optional, BytesN) for user-provided entropy, block metadata (BytesN) including block hash and timestamp for unpredictability, and a public identifier (String) like a user address or contract call ID to differentiate requests. The function outputs a 32-byte cryptographically generated random value along with a 64-byte verifiable proof, ensuring the randomness is tamper-proof and can be validated later.
Developers can integrate NebulaVRF in three ways:
On-Chain Soroban Contract – For fully trustless and verifiable randomness, ideal for DeFi, DAO governance, and NFT trait assignment.
Fast API Endpoint – For low-latency randomness, useful in gaming, real-time lotteries, and airdrops, with optional on-chain proof verification.
Rust-Based SDK (Cargo Package) – For backend applications needing secure randomness without blockchain overhead, such as AI models, or Web3 marketplaces.
Gaming & Lotteries – Fair dice rolls, loot box rewards, randomized game mechanics.
NFTs & Metaverse – Randomized trait distribution, rarity assignment.
DeFi & Airdrops – Random token distributions, fair reward allocation.
DAO Governance – Unbiased committee selection, randomized voting mechanics.
Yes
$34.0K
Success for NebulaVRF is defined by its adoption within the Stellar ecosystem as a reliable, on-chain randomness provider. A successful outcome includes at least 10+ projects integrating NebulaVRF for use cases in DeFi, gaming, DAOs, and NFTs. The VRF contract will be live on Stellar Mainnet, providing trustless randomness while maintaining high uptime and low-cost execution. The API should process 1,000+ monthly requests, and the Rust SDK should be actively used in backend applications. Developer engagement will be measured through GitHub activity, contributions, and discord discussions. Long-term success includes establishing NebulaVRF as the go-to randomness solution for anyone building in Soroban or Stellar.
Primary Users: Soroban dApp developers (DeFi, NFTs, DAOs, gaming).
Secondary Users: Backend developers needing verifiable randomness (via API/SDK).
Phase 1: Developer Beta (Testnet) – Month 1-2
Deploy Soroban Testnet Contract & launch NebulaVRF API.
Release Rust SDK (Cargo) for backend integration.
Conduct developer outreach via Stellar forums, twitter & Discord.
Phase 2: Mainnet Release – Month 3-4
Deploy VRF contract on Soroban Mainnet.
Provide developer documentation + GitHub repo.
Offer bounties for early adopters.
Phase 3: Adoption & Growth – Month 5+
Host hackathons & developer tutorials on youtube.
Secure integrations with major Soroban projects.
Promote through twitter, discord & ecosystem channels.
NebulaVRF is in the idea and technical design phase, aiming to build a native on-chain randomness beacon for Soroban. While not yet launched, most major blockchains have built-in VRF, which Stellar currently lacks. Ethereum uses Chainlink VRF, Polkadot has BABE-based randomness, and Solana integrates an oracle-assisted VRF. Without a trustless randomness source, Soroban developers must rely on off-chain randomness, centralized oracles, or block metadata, all of which introduce security risks and manipulation vectors.
Off-Chain Randomness – Manipulatable and unverifiable.
External Oracles – Requires trust in third-party providers (e.g., Chainlink, not available on Soroban).
Manual Entropy (Block Hashes, Timestamps) – Predictable and vulnerable to manipulation.
Fully On-Chain & Trustless – Eliminates reliance on oracles.
Low-Cost & Efficient – No extra transaction fees like Chainlink VRF.
Flexible Integration – Supports on-chain contract calls, API access, and an SDK for backend randomness.
Secure & Manipulation-Resistant – Uses commit-reveal and threshold cryptography to prevent last-mover bias.
Our initial outreach to Stellar developers confirms demand for a VRF solution, enabling secure, verifiable randomness for DeFi, gaming, and governance applications. NebulaVRF fills this gap, unlocking new possibilities for trustless applications on Soroban.
Brief Description:
The goal is to implement mathematically sound randomness that avoids predictable patterns like last-mover bias (vector bias)—a flaw where the final participant can influence randomness outcomes.
We will build a VRF (Verifiable Random Function) using threshold cryptography (BLS/Schnorr) and a commit-reveal scheme to prevent tampering. This will form the core randomness module for all NebulaVRF components
How to Measure Completion:
Rust-based VRF implementation with randomness proof generation.
Passes randomness tests (NIST or Chi-Square etc.).
Mathematical approach documented for transparency.
Estimated Date of Completion: Month 1-2
Budget: $8000
Brief Description:
Some use cases, like real-time web3 gaming and loot boxes, need fast randomness over trustless & costly randomness. The API will allow dApps to fetch high-speed, cryptographically strong randomness, while providing an optional proof submission to Soroban for on-chain verification if required.
How to Measure Completion:
API live with /get-random endpoint.
Developers can fetch randomness & optionally verify it on-chain.
Estimated Date of Completion: Month 2
Budget: $6000
Brief Description:
For DeFi, NFTs, and DAO governance, fully on-chain randomness is required to ensure trustlessness. We will create a VRF contract where the logic will be an abstraction of NebulaVRF’s core randomness module. We’ll then deploy it on Soroban Testnet, allowing developers to invoke it for verifiable randomness. Users would have to pay gas to invoke the smart contract.
How to Measure Completion:
Soroban contract live on Testnet.
Developers can request randomness via on-chain invoking (via Stellar JS SDK or RPC Calls)
Estimated Date of Completion: Month 3
Budget: $6000
Brief Description:
Some applications, like backend logic in Web3 marketplaces or AI models, don’t need an on-chain dependency but still require strong randomness. We will release a Rust Cargo package that Soroban developers can integrate for local randomness generation, with again an optional proof submission feature for verification on-chain.
How to Measure Completion:
Cargo package published & documented.
Developers can generate randomness locally & verify it on-chain if needed.
Estimated Date of Completion: Month 4
Budget: $7000
Brief Description:
Once tested, the VRF contract will go live on Stellar Mainnet, enabling trustless, fully decentralized randomness for all dApps. This phase also includes ongoing maintenance, ensuring high availability, security updates, and optimizations to keep the contract efficient and cost-effective for developers.
How to Measure Completion:
Mainnet contract deployment successful.
Developers actively using the contract in production.
Performance monitoring and bug fixes implemented as needed.
Optimizations for gas efficiency and security patches applied.
Estimated Date of Completion: Month 5-6
Budget: $7000
Mukund Jha:
I'm currently a university sophomore and I'm studying CS & AI. I have 3 years of full-stack programming experience. My skillset includes Rust, Typescript, Python & NodeJS based frameworks. I have been working in the web3 ecosystem for a year now, I initially started building projects and services on EVM chains but I switched to Non EVM 4 months back. I've been working with rust ever since & also have experience in working with MOVE for Sui & Aptos. I also study a lot of cryptography & logic, which was the source of insipiration for this idea. I will be leading this project
Sarthak Pandit:
Sarthak is also a university sophomore and is studying CS at Amity University. He has over 4 years of working experience with ReactJS, and is also good at Python & generalist programming. For his first year summer internship, he interned at Paypal. He is relatively new to web3.
Mukund Jha
No other submissions.