Ronin: Make a game's smart contract

• Ronin is an EVM-compatible chain optimized for large-scale Web3 gaming, offering streamlined gameplay and robust security.
• This tutorial walks you through deploying a Ronin node on the Saigon Testnet and creating a Hardhat-based smart contract for a simple blockchain game.
• The contract accepts deposits, verifies if players can participate, and pays out winners while retaining funds when players lose—illustrating a basic on-chain gaming model.
• You’ll learn to configure Hardhat, manage environment variables, and deploy your contract to Ronin for full transparency and fair gameplay.

​

Introduction to Ronin

​

Key technical features of Ronin

• Optimized for gaming: Ronin is designed to streamline the gaming experience by removing the complexities commonly found in other blockchains. This results in a platform that is efficient, with minimal spam and optimized uptime for games.
• Security enhancements: in response to security challenges faced in the past, Ronin has undergone extensive security overhauls. These include rigorous internal security protocols, comprehensive code reviews, and architecture audits to ensure robust security measures are in place.

​

Consensus mechanisms in Ronin

• Proof-of-authority (PoA) — Ronin initially utilized the PoA consensus mechanism. In this system, a select group of validators, trusted for their expertise and reputation, were responsible for maintaining the network. This approach facilitated faster transaction speeds and lower fees due to its energy-efficient design.
• Transition to delegated-proof-of-stake (DPoS) — Ronin integrated the DPoS consensus mechanism to advance decentralization. This allowed broader participation in the network’s maintenance, where anyone holding enough RON tokens could become a validator. While retaining the benefits of PoA, such as efficiency and low costs, this shift markedly improved the blockchain’s decentralization.

• Deploy a Ronin node on the Saigon Testnet.
• Create the game smart contract with Hardhat.
• Deploy the smart contract with Hardhat

​

Prerequisites

• Chainstack account to deploy a Ronin node.
• node.js as the JavaScript framework.
• Hardhat to create, deploy, and interact with contracts.

​

Overview

1. With Chainstack, create a public chain project.
2. With Chainstack, join the Ronin Saigon Testnet.
3. With Chainstack, access your Ronin node endpoint.
4. With Hardhat, create and set up the project.

​

Step-by-step

​

Create a public chain project

​

Join the Ronin Saigon testnet

​

Get your Ronin node endpoint

​

Fund your wallet

• Install the Ronin wallet.
• Use the Ronin faucet.

​

Install Hardhat

​

Install dotenv

npm i dotenv

​

Create a Hardhat project

npx hardhat

• Create a JavaScript project
• Do you want to install this sample project's dependencies with npm (hardhat @nomicfoundation/hardhat-toolbox)?

​

Edit the Hardhat configuration file

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

const RONIN_SAIGON_CHAINSTACK = process.env.RONIN_SAIGON_CHAINSTACK;
const PRIVATE_KEY = process.env.RONIN_PRIVATE_KEY;

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  networks: {
    saigon: {
      url: RONIN_SAIGON_CHAINSTACK,
      accounts: [PRIVATE_KEY],
    },
  },
  solidity: "0.8.23",
};

• require("@nomicfoundation/hardhat-toolbox"); imports the Hardhat Toolbox plugin, which provides several useful tools and utilities for Hardhat projects.
• require("dotenv").config(); loads environment variables from a .env file using the dotenv package.
• module.exports = { ... } exports a JavaScript object containing the configuration for the Hardhat project.
• solidity: "0.8.23", sets the Solidity compiler version to 0.8.23.
• networks: { ... } defines the network configurations for the Hardhat project. In this case, it defines a network called saigon that connects to the Ronin Saigon blockchain network.
• saigon: { ... } defines the configuration for the saigon network.
• url: RONIN_SAIGON_CHAINSTACK, sets the URL for the Saigon network using the RONIN_SAIGON_CHAINSTACK environment variable.
• accounts: [PRIVATE_KEY], sets the accounts for the saigon network using the PRIVATE_KEY environment variable. This will allow the Hardhat project to deploy contracts and interact with the Saigon network using the specified private key.

​

Create the game-handling smart contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

/// @title Game Contract
/// @notice This contract allows players to deposit ETH to play a game and handles game results and payouts.
contract Game {
    /// @notice Minimum deposit amount required to play the game
    uint256 public constant MINIMUM_DEPOSIT = 1 ether;

    /// @notice Maximum deposit amount allowed for the game
    uint256 public constant MAXIMUM_DEPOSIT = 2 ether;

    /// @notice Mapping to track user deposits
    mapping(address => uint256) public deposits;

    /// @notice Owner address
    address private owner;

    /// @notice Sets the contract deployer as the owner
    constructor() payable {
        owner = msg.sender;
    }

    /// @notice Ensures that only the owner can call the function
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can call this function");
        _;
    }

    /// @dev Deposits ETH to the contract to play the game
    /// @notice Deposits must be between 1 and 2 Ethers
    /// @notice Contract must have enough funds to pay potential winnings
    function deposit() public payable {
        require(msg.value >= MINIMUM_DEPOSIT && msg.value <= MAXIMUM_DEPOSIT, "Deposit must be between 1 and 2 Ethers");
        require(address(this).balance + msg.value >= MAXIMUM_DEPOSIT * 2, "Contract does not have enough funds to cover potential winnings");
        deposits[msg.sender] += msg.value;
    }

    /// @notice Checks if the user has enough deposit to play
    /// @param user The address of the user to check
    /// @return True if the user has enough deposit, false otherwise
    function canPlay(address user) public view returns (bool) {
        return deposits[user] >= MINIMUM_DEPOSIT;
    }

    /// @notice Handles the game result and processes payouts or deposit retention
    /// @dev Only callable by the owner
    /// @param player The address of the player
    /// @param userWon Indicates whether the player won or not
    function gameResult(address player, bool userWon) public onlyOwner {
        require(canPlay(player), "Player did not deposit enough to play");
        uint256 depositAmount = deposits[player];

        if (userWon) {
            require(address(this).balance >= depositAmount * 2, "Contract does not have enough funds");
            payable(player).transfer(depositAmount * 2);
        } else {
            // Keep the deposit in the contract if AI wins
        }

        deposits[player] = 0;
    }

    /// @notice Allows the owner to withdraw all funds from the contract
    /// @dev Only callable by the owner
    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No funds to withdraw");
        payable(owner).transfer(balance);
    }

    // Additional functions can be added here
}

​

Understanding the smart contract

​

Contract overview

• Contract name — Game
• Purpose — this contract allows players to deposit ETH to play a game, and it manages the game results and payouts.

​

Constants

1. MINIMUM_DEPOSIT
   • Type — uint256 (unsigned integer)
   • Purpose — specifies the minimum amount of ether a player must deposit to play the game.
   • Value — 1 ether
2. MAXIMUM_DEPOSIT
   • Type — uint256
   • Purpose — indicates the maximum amount of ether a player can deposit.
   • Value — 2 ethers

​

State variables

1. deposits
   • Type — mapping(address => uint256)
   • Purpose — keeps track of the amount of ether each player (address) has deposited.
2. owner
   • Type — address
   • Purpose — stores the address of the contract owner, who has special privileges (like executing the gameResult and withdraw functions).

​

Constructor

• Functionality — sets the deployer of the contract as the owner.

​

Modifiers

1. onlyOwner
   • Purpose — restricts the execution of certain functions to only the contract owner.

​

Functions

1. deposit
   • Access — public
   • Payment Type — payable (can receive ether)
   • Purpose — allows players to deposit ETH within the allowed range (1 to 2 ethers). It also ensures the contract has enough funds to cover potential winnings.
   • Logic — updates the deposits mapping with the player’s deposit amount.
2. canPlay
   • Access — public
   • Purpose — checks if a user has deposited enough ETH to play the game.
   • Parameters — user (address of the player)
   • Returns — bool (True if the player has enough deposit, False otherwise)
3. gameResult
   • Access — public, but restricted to onlyOwner
   • Purpose — processes the outcome of the game. It either pays out double the deposit to the player if they win or retains the deposit in the contract if they lose.
   • Parameters:
     • player — address of the player
     • userWon — boolean indicating whether the player won or not
   • Logic — if the player wins, it transfers double the deposit amount to them and resets their deposit to zero. If the player loses, just resets their deposit.
4. withdraw
   • Access — public, but restricted to onlyOwner
   • Purpose — allows the owner to withdraw all ETH stored in the contract.
   • Logic — transfers the entire contract balance to the owner’s address.

​

TL;DR

• Players can participate in the game by depositing a certain amount of ether (between 1 and 2 ethers).
• The contract ensures fairness and readiness for payouts before accepting deposits.
• After the game ends, the result is communicated to the contract. Winners receive double their stake, while the stakes of those who lose remain with the contract.
• Only the contract owner can process game results and withdraw funds from the contract, ensuring controlled and secure operations.

​

Environment variables

RONIN_SAIGON_CHAINSTACK="YOUR_CHAINSTACK_RONIN_ENDPOINT"
RONIN_PRIVATE_KEY="YOUR_RONIN_WALLET_PRIVATE_KEY"

​

Create the deploying script

const hre = require("hardhat");

async function main() {
  console.log("Deploying contract...");
  const GameContract = await hre.ethers.deployContract("Game");

  // Deploy the contract.
  await GameContract.waitForDeployment();
  console.log("Contract deployed to:", GameContract.target);
  const roninAddress = GameContract.target.substring(2);
  console.log(
    `Find the contract at https://saigon-app.roninchain.com/address/ronin:${roninAddress}`
  );
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

1. Import Hardhat runtime environment (HRE):
   Javascript

   Copy

   const hre = require("hardhat");
   

   This line imports the Hardhat runtime environment, which provides various utilities for working with Ethereum, such as deploying contracts.
2. Main function:
   Javascript

   Copy

   async function main() {
     console.log("Deploying contract...");
     const GameContract = await hre.ethers.deployContract("Game");
   
     // Deploy the contract.
     await GameContract.waitForDeployment();
     console.log("Contract deployed to:", GameContract.target);
     const roninAddress = GameContract.target.substring(2);
     console.log(
       `Find the contract at https://saigon-app.roninchain.com/address/ronin:${roninAddress}`
     );
   }
   

   The main function is an asynchronous function where the main logic of the script is executed.
3. Starting deployment process:
   Javascript

   Copy

   console.log("Deploying contract...");
   

   This line prints a message to the console indicating that the deployment process is starting.
4. Deploying the contract:
   Javascript

   Copy

   const GameContract = await hre.ethers.deployContract("Game");
   

   This line uses Hardhat’s ethers plugin to deploy a contract named Game. The await keyword is used because deployContract is an asynchronous operation.
5. Waiting for deployment completion:
   Javascript

   Copy

   await GameContract.waitForDeployment();
   

   This line waits for the contract deployment to be completed. It’s important to wait for the deployment to finish before proceeding.
6. Logging the deployed contract address:
   Javascript

   Copy

   console.log("Contract deployed to:", GameContract.target);
   

   After the contract is successfully deployed, this line logs the address of the deployed contract to the console.
7. Removing the 0x prefix from the address:
   Javascript

   Copy

   const roninAddress = GameContract.target.substring(2);
   

   This line removes the 0x prefix from the Ethereum address using the substring method. As the Ronin explorer uses this format: https://saigon-app.roninchain.com/address/ronin:49a1EA88e5F81850DE30Dc038c1d08028ecFc9b5.
8. Providing the contract address on Ronin explorer:
   Javascript

   Copy

   console.log(
       `Find the contract at https://saigon-app.roninchain.com/address/ronin:${roninAddress}`
   );
   

   This line constructs a URL to view the contract on the Ronin blockchain explorer and logs it to the console. It appends the modified address to the explorer’s URL.
9. Error handling:
   Javascript

   Copy

   main().catch((error) => {
     console.error(error);
     process.exitCode = 1;
   });
   

   This part of the script ensures that if any errors occur during the execution of the main function, they are caught and printed to the console, and the script exits with an error code.

​

Deploy the smart contract

npx hardhat run --network saigon scripts/deploy.js

Deploying contract...
Contract deployed to: 0x49a1EA88e5F81850DE30Dc038c1d08028ecFc9b5
Find the contract at https://saigon-app.roninchain.com/address/ronin:49a1EA88e5F81850DE30Dc038c1d08028ecFc9b5

​

Next steps

​

Conclusion

​

About the author

Ake

Director of Developer Experience @ Chainstack Talk to me all things Web320 years in technology | 8+ years in Web3 full time years experienceTrusted advisor helping developers navigate the complexities of blockchain infrastructure