The Ideal Network is live on Paseo!

Ecosystem
1

:game_die: Ideal Network is Live on Paseo

Verifiable Randomness for Parachains and ink! Smart contracts

Hey all,

I’m excited to announce that, after months of work and overcoming unexpected challenges, the Ideal Network is now live on Paseo!

What is IDN?

The IDN provides verifiable randomness as a service (VRaaS) for the Polkadot ecosystem, like /dev/random for blockchains. Any parachain runtime or ink! smart contract (v5+) can now access cryptographically secure randomness through a simple subscription model!

Why this Matters

Until now, web3 developers on Polkadot building games, NFT projects, lotteries, and other protocols requiring randomness have had to rely on:

  • Insecure randomness (blockhashes, timestamps) - manipulable by collators
  • Consensus-Layer VRFs (BABE VRF) - cryptographically secure but validators know their VRF outputs in advance for the entire epoch; it is designed for leader election, not on-demand randomness in an application layer

There is no standardized way to consume babe vrf’s output either, with many projects introducing bespoke solutions, such as:

The IDN brings unpredictable, verifiable randomness as a service for parachain runtimes and smart contracts:

  • On-demand Randomness - All outputs are unpredictable until revealed, unlike consensus-driven VRFs
  • Subscription-based Pricing - Predictable costs under your control, not per-call fees.
  • Blockchain-Native - No manual oracle interaction is needed for parachains, just create a subscription and receive randomness.
  • Future Timelock Encryption Support - We are working on integrating a fully encrypted transaction pool powered by timelock encryption, eliminating MEV and front-running entirely from the Ideal Network.
  • Multiple Integration Paths - The solution can be integrated with smart contracts or directly into a runtime. In addition, contracts deployed on the IDN receive randomness for free.

Getting Started

Documentation: https://docs.idealabs.network.

Integration Preview

Here’s how simple it is to receive randomness in an ink! smart contract:

use idn_contracts::prelude::*;
// Receive randomness in your contract
fn consume_pulse(&mut self, pulse: Pulse, _: SubscriptionId) -> IDNResult {
    let randomness = pulse.rand();
    // use it here!
    Ok(())
}

→ See the complete integration guide

We’ve built a few examples to help get you started:

  • Verifiable-Flipper - Bet against provably fair coin flips
  • Lottery - A simple lottery using VRaaS.
  • Plinko - An automated web3 game powered by IDN randomness
  • Gacha - Built to be natively deployed on the IDN, uses our custom chain extension to consume randomness

Check out the consumer-contract example for an example of a full integration with the subscription management system.

Three Integration Paths

1. Smart Contracts (ink! v5+)

Your contract manages subscriptions to IDN and receives randomness through your consume_pulse implementation.

→ View the smart contract integration guide

2. Runtime Pallet

Integrate IDN directly into your runtime for making randomness accessible throughout block execution.

→ View the runtime integration guide

:warning: IMPORTANT: You need to open an HRMP channel between the parachain and the IDN for either path (1) or (2) to work.

3. Native Contracts

Build contracts that read verifiable randomness directly from the IDN runtime at no cost. This is ideal for use case that need to ‘pull’ randomness rather than have it pushed.

→ View the native ink! smart contract integration guide

We Want Your Feedback!

This is our first release that we are making available to the community. We are eager to hear from builders:

  • What are you building that needs randomness?
  • What would make IDN more useful for your needs?
  • Found any issues or bugs? Let us know!

Join our community:

Looking forward to seeing what you build!

Thanks,
The Ideal Labs Team
@driemworks
@colemanirby
@juangirini
@carloskiron

5 Likes