Introducing Orand: Your Trustless Source of Randomness

Table of Contents

As decentralized applications (dApps) continue to evolve, the need for secure and reliable sources of randomness has become increasingly important. Randomness is an essential component of many dApps, from online gaming platforms to blockchain-based lotteries. However, traditional methods of generating random numbers have their limitations. That's where Orand comes in. Orand is a verifiable random function that acts as a decentralized and trustless source of randomness for your dApp needs. In this article, we are going to introduce to you Orand, a verifiable random function developed by Orochi Network.

What is Orand?

Orand is a verifiable random function based on elliptic curves (ECVRF) that generates unpredictable and tamper-proof random numbers using advanced cryptographic algorithms. The ECVRF as a service of Orand is distributed across a network of nodes, making it difficult to manipulate or tamper with. Orand provides maximum security, fairness, and transparency, making it an ideal solution for dApps that require impartial and trustworthy sources of randomness. As a system library of UnityOS (Orochi Computation Layer), Orand can provide randomness for all dApps on Orochi Network’s zkWASM and smart contracts on supported Layer-1 chains.

Features of Orand

Diversity
- A distributed system with many participants/nodes will join to generate randomness by using Multi Party Computation (MPC).
Unpredictability
- An ECVRF performs on input the previous randomness and it also requires half of participants to join the process.
High throughput
- Game server could request randomness from the Orand system. The result will be provided as soon as half of participants participate in the protocol.
Cheap and secure randomness
- For the free tier, 1,000 randomness will be given freely every month.
- Only 1 transaction needed to submit results to smart contracts
Hybrid Proof: Validity Proof (By Default) and Fault Proof (If Requested)
- Validity proof: Orand supports validity proof by default and it is used to confirm that the output of Orand is a valid and correctly computed random value. Orand provides a built-in validity proof that can be easily verified by anyone using the public parameters of the function. This proof is designed to ensure that the output of Orand has not been tampered with or manipulated in any way.
- Fault proof: A fault proof is an optional feature that can be requested by customers who require additional security guarantees. A fault proof is used to ensure that the Orand function has not been compromised in any way, even if an attacker has access to the internal state of the function.
Dual Proof: An ECDSA proof will be combined with an ECVRF proof secure the feeding process, allowing it to be done by any third party while still guaranteeing the result to be verifiable and immutable.
Batching: Each epoch can provide up to 5000 randomness depending on the capacity of the settlement layer. This is significantly useful for blockchain projects who want to distribute a large number of NFTs since it allows projects to issue up to 5000 NFTs in a single epoch.
Multi-chain
- All EVM-compatible blockchains can be supported

How does Orand work?

Orand is a verifiable random function (VRF) that is based on elliptic curve cryptography. The Orand algorithm is designed to take a secret key, a public key, and an input string and generate a random output value that is unique to that input string. The output value is computationally indistinguishable from a truly random value, meaning that it is very difficult to predict or reproduce without knowledge of the secret key.

The Orand algorithm uses elliptic curve cryptography to ensure the security and randomness of the output value. Specifically, it uses a bilinear pairing function to generate a random value that is derived from the input string and the secret key. The resulting value is then hashed using a cryptographic hash function to produce the final output value.

In addition to generating random output values, Orand also provides verifiable proofs of the validity of the output values. These proofs can be verified using only the public key of the Orand function, which means that anyone can independently verify the randomness and validity of the output value. The verifiable proof is based on a non-interactive zero-knowledge proof that is generated along with the output value. The proof ensures that the output value is correctly computed and derived from the secret key and input string.

What are the benefits of using Orand?

One of the key benefits of Orand is its verifiability. Every random number generated by Orand is cryptographically verifiable, which means you can be sure that the results are truly random and have not been manipulated. Our product uses a secure and transparent verification process, which makes it easy to verify the authenticity of the random numbers generated by Orand.

Another benefit of using Orand is its flexibility. Our product can be easily integrated into your dApp, and it can be customized to meet your specific requirements. Whether you need to generate random numbers for gaming, lotteries, or any other application, Orand can help you achieve your goals with ease.

Lastly, one of the most outstanding benefits of Orand is the implementation of dual proofs, including ECDSA and ECVRF proof, which offer higher security during randomness feeding process compared to other verifiable random functions. This application makes the epoch publishing process of Orand more flexible and secure.

How to request randomness from Orand?

Using Orand is simple. Our product can be easily integrated into your dApp, allowing you to access the random numbers generated by Orand in real-time.

Here are the basic steps to use Orand in your smart contracts:

1. First, your smart contract that consumes Orand’s randomness needs the interface of IOrandConsumerV1 to be implemented, which was described below:

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.0;

error InvalidProvider();

interface IOrandConsumerV1 {
  function consumeRandomness(uint256 randomness) external returns (bool);
}

2. It’s important to note that your application can request the verifiable randomness directly from Orand. Then you can publish the randomness yourself by calling the method publish() on OrandProviderV1 smart contract. Higher tier of service establishes the ability to submit the randomness from Orand service but the deal will cover the cost for each randomness.

3. To request randomness from Orand, following the code below:

import {
  orand,
  IOrandEpoch,
  OrandProviderV1,
  abiOrandProviderV1,
} from "@orochi-network/sdk";
import { ethers } from "ethers";

(async () => {
  // Create an instance of Orand
  const orandInstance = new orand.Orand({
    url: "ORAND_SERVICE_URL",
    user: "ORAND_USER_NAME",
    secretKey: "ORAND_USER_HMAC_SECRET",
    consumerAddress: "ORAND_USER_CONSUMER_ADDRESS",
    chainId: 97,
  });
})();

ORAND_SERVICE_URL: We will provide you the service URL
ORAND_USER_NAME: The username that you registered with Orand service, e.g: "Navi"
ORAND_USER_HMAC_SECRET: The random secret key used to authenticate yourself, for instance, 6b1ab607287f5379db8b70bb7515feaa
ORAND_USER_CONSUMER_ADDRESS: The consumer smart contract address for instance, "0x66681298BBbdf30a0B3Ec98cAbf41AA7669dc201"

Note: ChainId is a predefined value, you can check the chain list here.

4. Once you get all step above finished, you can be able to submit the randomness to your smart contract following:

// Restore wallet from passphrase and connect it to JSON provider
let wallet = ethers.Wallet.fromPhrase(
  "YOUR_12_WORD_PASSPHRASE",
  new ethers.JsonRpcProvider("https://data-seed-prebsc-1-s1.binance.org:8545")
);

// Get epoch data from Orand
const data: IOrandEpoch = await orandInstance.newPrivateEpoch();

// Create an instance of OrandProviderV1
const orandProviderV1 = (<OrandProviderV1>(
  (<any>(
    new ethers.Contract(
      "0x75C0e60Ca5771dd58627ac8c215661d0261D5D76",
      abiOrandProviderV1
    )
  ))
)).connect(wallet);

// Convert Orand proof to smart contract proof
const [ecdsaProof, epoch] = orandInstance.transformProof(data);
console.log([ecdsaProof, epoch]);

// Publish the proof
await orandProviderV1.publishValidityProof(ecdsaProof, epoch);

For more detailed information, please have a visit at our Cookbook. In case you have any other questions or need urgent assistance, please contact us at: t.me/OrochiNetwork

How to purchase Orand?

Orand offers a flexible subscription model that allows users to choose a plan that best suits their needs. The subscription model includes four different packages, each with varying features and prices. Contact for more detail information.

Free Package

The Free Package is an ideal option for users who are just getting started with Orand. This package is completely free of charge and offers general randomness per month, which is ideal for smaller dApps. However, this package comes with limited functionality, making it a great option for users who are looking to try out the Orand platform.

Growth Package

The Growth Package is designed for users who need a more robust and flexible solution. this plan grants a significant increase in randomness allotment compared to the Free Plan. It also allows up to 5 applications to be integrated with Orand. Additionally, users will have access to greater support from the Orand team, making it easier to get the most out of the product.

Business Package

The Business Package is ideal for businesses that require a larger number of random numbers. This plan offers an even larger allotment at a more cost-effective rate per unit. It also allows up to 10 applications to be integrated with Orand. With this package, users will have access to live support 24/7, making it easy to get help when they need it.

Enterprise Package

For users who need even more flexibility and customization, Orand offers an Enterprise Package. The Enterprise Package is designed to meet the unique needs of large businesses and organizations, and the pricing is negotiable. This package includes all the features of the other packages, as well as additional customizations and support tailored to the user's specific needs.

Final Words

Orand is a verifiable random function that provides a trustless and decentralized source of randomness for your dApp needs. Our product is designed to provide maximum security, transparency, and fairness, making it an ideal solution for applications that require impartial and trustworthy sources of randomness. With Orand, you can be sure that the random numbers generated for your dApp are truly random and have not been manipulated. Try Orand today and experience the power of trustless and decentralized randomness in your dApp!

If you are interested in using Orand, don’t hesitate to contact us at: [email protected]

About Orochi Network

Orochi Network is a cutting-edge zkOS (An operating system based on zero-knowledge proof) designed to tackle the challenges of computation limitation, data correctness, and data availability in the Web3 industry. With the well-rounded solutions for Web3 Applications, Orochi Network omits the current performance-related barriers and makes ways for more comprehensive dApps hence, becoming the backbone of Web3's infrastructure landscape.