> ## Documentation Index > Fetch the complete documentation index at: https://hedera-0c6e0218-mintlify-bc559771.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # How to Generate a Random Number on Hedera > Generate verifiable pseudorandom numbers on Hedera using the native PrngTransaction or the Solidity precompile for lotteries, gaming, and fair NFT drops. Pseudorandom numbers are used in applications like lotteries, gaming, and even random selection in NFT sales/giveaways. In some cases, it is necessary to prove to third parties that a random number was generated without the influence or control of a user/application. With Hedera, you have a transaction and Solidity library available to generate pseudorandom numbers with just a few lines of code. This means that when your application generates a random number, anyone can verify that the number was truly generated by the Hedera network – without being influenced by any one user. In this tutorial, you will learn how to generate random numbers on Hedera using the [JavaScript SDK](/native/fundamentals#hedera-services-code-sdks) and Solidity. Keep in mind that the random number generator covered here is secure enough for practical applications, but you should carefully consider whether it is secure enough for your specific purpose. For details on limitations and security considerations, see [HIP-351](https://hips.hedera.com/hip/hip-351) (special mention and thanks to LG Electronics for the help and input in formulating this Hedera Improvement Proposal). This[ resource](https://www.wolfssl.com/true-random-vs-pseudorandom-number-generation/) is helpful if you want to learn more about the difference between pseudorandom and random numbers. For simplicity, we’ll use both terms interchangeably throughout this tutorial. *** ## Prerequisites * Get a [Hedera Testnet](https://portal.hedera.com/register) account [here](/native/tutorials/getting-started/create-fund-account). * Get the [example code from GitHub](https://github.com/ed-marquez/hedera-example-random-number/blob/master/index.js). * Set up your environment and create a client here. **\*📣 Note:** This tutorial requires the use of the following tools: Hedera\* [*JavaScript SDK*](/native/fundamentals)*, Solidity with libraries for random number generation (*[*HIP-351*](https://hips.hedera.com/hip/hip-351)*), and the Mirror Node REST API (*[*learn more*](https://hedera.com/blog/how-to-look-up-transaction-history-on-hedera-using-mirror-nodes-back-to-the-basics)*) and explorer (*[*HashScan*](https://hashscan.io/#/mainnet/dashboard)\*).\* *** ## Table of Contents 1. [Generate Random Numbers (SDK)](#generate-random-numbers-using-the-sdk) 2. [Generate Random Numbers (Solidity)](#generate-random-numbers-using-solidity) 1. [Deploy Contract](#deploy-contract) 2. [Execute Contract](#execute-contract) 3. [Query Results](#query-results) 3. [Summary](#summary) 4. [Additional Resources](#additional-resources) *** ## **Generate Random Numbers Using the SDK** **Step 1:** The Operator is the only account involved in submitting transactions to the Hedera network. Your testnet credentials from the [Hedera portal](https://portal.hedera.com/register) should be used for the operator variables, which are used to initialize the Hedera client that submits transactions to the network and gets confirmations. * The constants ***lo*** and ***hi*** are the lower and upper limits for the random number, respectively * Generate a random number (***randomNum***) 5 times with a ***for loop*** * Use [**PrngTransaction()**](/native/prng) in the SDK to create a transaction that generates a pseudorandom number * If a positive value is provided to the ***setRange()*** method, then the transaction record will contain a 32-bit pseudorandom integer that is equal or greater than 0 and less than ***hi*** * If a range is not specified, then the transaction record contains the 384-bit array of pseudorandom bits * The ***client*** is used to execute the transaction and obtain the transaction record * Output to the console the random number for each loop run ```javascript index.js theme={null} // STEP 1 =================================== console.log(`\nSTEP 1 ===================================\n`); console.log(`- Generating random numbers with the SDK...\n`); const lo = 0; const hi = 50; let randomNum = []; for (var i = 0; i < 5; i++) { const randomNumTx = await new PrngTransaction().setRange(hi).execute(client); const randomNumRec = await randomNumTx.getRecord(client); randomNum[i] = randomNumRec.prngNumber; console.log(`- Run #${i + 1}: Random number = ${randomNum[i]}`); } ``` STEP 1 =================================== \- Generating random numbers with the SDK... \- Run #1: Random number = 10 \- Run #2: Random number = 7 \- Run #3: Random number = 14 \- Run #4: Random number = 44 \- Run #5: Random number = 27 *** ## **Generate Random Numbers Using Solidity** **Step 2:** Deploy a Solidity smart contract to generate the random number. After completing all steps, your console should look something like [this](#console-output-1). ### Deploy Contract In the `index.js` file: * Set the gas limit (***gasLim***) to be 4,000,000 and define the contract ***bytecode*** * Deploy the contract using the helper function ***contracts.deployContractFcn*** * The function returns the ***contractId*** in Hedera format and ***contractAddress*** in Solidity format * The inputs are the ***bytecode***, ***gasLim***, and ***client*** * Output to the console ***contractId*** and ***contractAddress*** You can see the Solidity contract ***PrngSystemContract*** in the second tab below. This example calls a precompiled contract with address 0x169. For additional details about the contract and the functions ***getPseudorandomSeed*** and ***getPseudorandomNumber***, check out [HIP-351](https://hips.hedera.com/hip/hip-351). The first function generates a 256-bit pseudorandom seed and returns the corresponding bytes; you can then use that seed to get a random number. The second function operates on those bytes to return the random number. There is also a contract function ***getNumber*** which reads the random number from the contract state variable, ***randNum***. ```javascript Index.js theme={null} // STEP 2 =================================== console.log(`\nSTEP 2 ===================================\n`); console.log(`- Generating random number with Solidity...\n`); // Deploy the Solidity contract let gasLim = 4000000; const bytecode = contract.object; const [contractId, contractAddress] = await contracts.deployContractFcn( bytecode, gasLim, client ); console.log(`- Contract ID: ${contractId}`); console.log(`- Contract ID in Solidity address format: ${contractAddress}`); ``` ```javascript PrngSystemContract.Sol theme={null} // SPDX-License-Identifier: Apache-2.0 pragma solidity >=0.4.9 <0.9.0; import "./IPrngSystemContract.sol"; contract PrngSystemContract { address constant PRECOMPILE_ADDRESS = address(0x169); uint32 randNum; function getPseudorandomSeed() external returns (bytes32 randomBytes) { (bool success, bytes memory result) = PRECOMPILE_ADDRESS.call( abi.encodeWithSelector(IPrngSystemContract.getPseudorandomSeed.selector)); require(success); randomBytes = abi.decode(result, (bytes32)); } /** * Returns a pseudorandom number in the range [lo, hi) using the seed generated from "getPseudorandomSeed" */ function getPseudorandomNumber(uint32 lo, uint32 hi) external returns (uint32) { (bool success, bytes memory result) = PRECOMPILE_ADDRESS.call( abi.encodeWithSelector(IPrngSystemContract.getPseudorandomSeed.selector)); require(success); uint32 choice; assembly { choice := mload(add(result, 0x20)) } randNum = lo + (choice % (hi - lo)); return randNum; } function getNumber() public view returns (uint32) { return randNum; } } ``` **Helper Functions:** The function ***contracts.deployContractFcn*** uses [**ContractCreateFlow()**](/native/smart-contracts/create#contractcreateflow) to store the bytecode and deploy the contract on Hedera. This single call handles for you the operations [**FileCreateTransaction()**](/native/files/create), [**FileAppendTransaction()**](/native/files/append), and [**ContractCreateTransaction()**](/native/smart-contracts/create#contractcreatetransaction). This helper function simplifies the contract deployment process and is reusable in case you need to create more contracts in the future. ```javascript theme={null} export async function deployContractFcn(bytecode, gasLim, client) { const contractCreateTx = new ContractCreateFlow() .setBytecode(bytecode) .setGas(gasLim); const contractCreateSubmit = await contractCreateTx.execute(client); const contractCreateRx = await contractCreateSubmit.getReceipt(client); const contractId = contractCreateRx.contractId; const contractAddress = contractId.toSolidityAddress(); return [contractId, contractAddress]; } ``` ### Execute Contract * Use the helper ***contracts.executeContractFcn*** to execute the contract function ***getPseudorandomNumber*** * Use **ContractFunctionParameters()** from the SDK to specify the parameters for the contract function (***randNumParams***). Pass the lower (***lo***) and upper (***hi***) limits for the random number * The inputs are the contract ID (***contractId***), the contract function to execute, ***randNumParams***, ***gasLim,*** and ***client*** * The contract function calls a precompiled contract and gets the bytes for the random seed. The random number is calculated, stored in the state variable ***randNum***, and returned by the function * The helper function returns the record object of the transaction (***randNumRec***), which is used to obtain the status of the transaction * Output to the console: * The status of the contract call ```javascript theme={null} // Execute the contract const randNumParams = new ContractFunctionParameters() .addUint32(lo) .addUint32(hi); const randNumRec = await contracts.executeContractFcn( contractId, "getPseudorandomNumber", randNumParams, gasLim, client ); console.log(`- Contract execution: ${randNumRec.receipt.status} \n`); ``` **Helper Functions:** The function ***contracts.executeContractFcn*** uses [**ContractExecuteTransaction()**](/native/smart-contracts/call) in the SDK to call the specified contract function. ```javascript theme={null} export async function executeContractFcn(cId, fcnName, params, gasLim, client) { const contractExecuteTx = new ContractExecuteTransaction() .setContractId(cId) .setGas(gasLim) .setFunction(fcnName, params); const contractExecuteSubmit = await contractExecuteTx.execute(client); const contractExecuteRec = await contractExecuteSubmit.getRecord(client); return contractExecuteRec; } ``` ### Query Results You will learn various ways to obtain the random number from the Solidity contract. The best approach depends on your use case and preference. You can get the random number by: using a transaction record, doing a contract call to read state variables, and checking a mirror node explorer. * Use the helper function ***queries.txRecQueryFcn*** to obtain information from the transaction record * The function returns a record query object (***recQuery***) * The inputs are the ID of the relevant transaction from the record object (***randNumRec.transactionId***) and ***client*** * The query of the transaction record, ***recQuery***, was configured to return information on child transactions. Thus, the first child transaction of the contract execution (parent transaction) contains information about the bytes needed for the random number – see ***recQuery.children\[0].prngBytes*** * The random number is obtained from doing a modulo operation (%) of the integer value of the last four bytes and the specified range * Use the helper ***contracts.callContractFcn*** to call the contract function ***getNumber***, which reads the random number from a state variable in the contract * The inputs are ***contractId***, the contract function to call, ***gasLim***, and ***client*** * The helper function returns ***randNumResult***, which is used to obtain the random number * Use the helper function ***queries.mirrorTxQueryFcn*** to obtain transaction information from the mirror nodes * The function returns a [mirror node REST API](https://hedera.com/blog/how-to-look-up-transaction-history-on-hedera-using-mirror-nodes-back-to-the-basics) request about the relevant transaction (***randNumInfo***) and a string with a mirror explorer URL (***randNumExpUrl***) * The input is the ID of the relevant transaction from the record object (***randNumRec.transactionId***) * Output to the console: * The random number obtained using both the transaction record and using the contract function * A message indicating if the random number obtained with the two methods above matches or not * The mirror node explorer URL with more details about the transaction ```javascript theme={null} // Query the transaction record to get the random number from bytes const recQuery = await queries.txRecQueryFcn(randNumRec.transactionId, client); let lowOrderBytes = new Uint8Array(recQuery.children[0].prngBytes).slice(28, 32); let dataview = new DataView(lowOrderBytes.buffer); let range = hi - lo; let int32be = dataview.getUint32(0); let randNum = int32be % range; console.log(`- The random number (using transaction record) = ${randNum}`); // Call the contract to read random number using the getNumber function const randNumResult = await contracts.callContractFcn(contractId, "getNumber", gasLim, client); console.log(`- The random number (using contract function) = ${randNumResult.getUint32(0)}`); randNum === randNumResult.getUint32(0) ? console.log(`- The random number checks out ✅`) : console.log(`- Random number doesn't match ❌`); // Check a Mirror Node Explorer const [randNumInfo, randNumExpUrl] = await queries.mirrorTxQueryFcn(randNumRec.transactionId); console.log(`\n- See details in mirror node explorer: \n${randNumExpUrl}`); console.log(` ==================================================== THE END - NOW JOIN: https://hedera.com/discord ====================================================\n`); } ``` **Helper Functions** The function ***queries.txRecordQueryFcn*** uses [**TransactionRecordQuery()**](/native/transactions/record) in the SDK to obtain details about the contract execution transaction. Note that the .***setIncludeChildren*** method is set to true to get information about all the children transactions under the contract execution – this includes the transaction generating the random number. The function ***contracts.callContractFcn*** uses [**ContractCallQuery()**](/native/smart-contracts/get-function) in the SDK to call a contract function that reads a state variable containing the random number. The function ***queries.mirrorTxQueryFcn*** obtains transaction information from the mirror nodes. The function introduces a delay of 10 seconds to allow for the propagation of information to the mirror nodes. It then formats the transaction ID and performs string operations to return a mirror REST API query and a mirror node explorer URL. ```javascript Queries.TxRecordQueryFcn theme={null} export async function txRecQueryFcn(txId, client) { const recQuery = await new TransactionRecordQuery() .setTransactionId(txId) .setIncludeChildren(true) .execute(client); return recQuery; } ``` ```javascript Contracts.CallContractFcn theme={null} export async function callContractFcn(cId, fcnName, gasLim, client) { const contractCallTx = new ContractCallQuery() .setContractId(cId) .setGas(gasLim) .setFunction(fcnName); const contractCallSubmit = await contractCallTx.execute(client); return contractCallSubmit; } ``` ```javascript Queries.MirrorTxQueryFcn theme={null} export async function mirrorTxQueryFcn(txIdRaw) { // Query a mirror node for information about the transaction const delay = (ms) => new Promise((res) => setTimeout(res, ms)); await delay(10000); // Wait for 10 seconds before querying a mirror node const txIdPretty = prettify(txIdRaw.toString()); const mirrorNodeExplorerUrl = `https://hashscan.io/testnet/transaction/${txIdPretty}`; const mirrorNodeRestApi = `https://testnet.mirrornode.hedera.com/api/v1/transactions/${txIdPretty}`; let mQuery = []; try { mQuery = await axios.get(mirrorNodeRestApi); } catch {} return [mQuery, mirrorNodeExplorerUrl]; } function prettify(txIdRaw) { const a = txIdRaw.split("@"); const b = a[1].split("."); return `${a[0]}-${b[0]}-${b[1]}`; } ``` STEP 2 =================================== \- Generating random number with Solidity... \- Contract ID: 0.0.49020098 \- Contract ID in Solidity address format: 0000000000000000000000000000000002ebfcc2 \- Contract execution: SUCCESS \- The random number (using transaction record) = 14 \- The random number (using contract function) = 14 \- The random number checks out ✅ \- See details in mirror node explorer: [https://hashscan.io/testnet/transaction/0.0.2520793-1670012876-681938430](https://hashscan.io/testnet/transaction/0.0.2520793-1670012876-681938430) *** ## **Summary** Now you know how to generate a random number on Hedera using the JavaScript SDK and Solidity libraries. Try this example with the other officially supported [SDKs](/native/fundamentals#hedera-services-code-sdks) for Java, Go, and Swift (coming soon). **Congratulations! 🎉 You have successfully learned how to generate a random number on Hedera. Feel free to reach out on** [**Discord**](https://hedera.com/discord) **if you have any questions!** *** ## Additional Resources **➡** [**Project Repository**](https://github.com/ed-marquez/hedera-example-random-number) **➡** [**WolfSSL Random Number Guide**](https://www.wolfssl.com/true-random-vs-pseudorandom-number-generation/) [GitHub](https://github.com/ed-marquez) | [LinkedIn](https://www.linkedin.com/in/ed-marquez/) | [X](https://X.com/ed__marquez) [GitHub](https://github.com/theekrystallee) | [X](https://X.com/theekrystallee)