Skip to content
Eidolon

Controlling Access with Token Gating in Blockchain Gaming

Token gating in blockchain gaming is a powerful concept that allows game developers to manage access to in-game assets, particularly non-fungible tokens (NFTs), using smart contract logic. This practice adds depth and strategy to blockchain-based games, where players can own various digital assets like characters, items, or collectibles. Token gating enables developers to impose specific conditions or restrictions on how these assets are used within the game world.

Key Use Cases for Token Gating

Here are some key use cases for token gating in blockchain gaming:

1. Unlock Content

Token gating can be used to unlock exclusive in-game content, levels, or features for players who own specific NFTs. For instance, owning a rare sword NFT might grant access to unique game quests or challenges.

2. Grant Permissions

Token gating allows game developers to grant special permissions or abilities to players who possess particular NFTs. For example, owning a unique character NFT might provide additional in-game abilities or powers.

3. Control Transfer

Smart contract-based token gating can limit the transfer or trade of in-game assets, ensuring that only players who meet specific criteria, such as owning a particular NFT or achieving a specific in-game level, can participate.

By incorporating token gating into gameplay, developers can introduce scarcity, uniqueness, and intrinsic value to in-game assets, enhancing the overall gaming experience.

Example Code for Fetching Token Ownership

Let’s explore example code for fetching ownership of ERC-721 and ERC-1155 tokens in Unity using Eidolon. These code snippets assume that you have already deployed your own ERC-721 and ERC-1155 smart contracts.

Fetching ERC-721 Token Owner

using System;
using System.Numerics;
using System.Threading.Tasks;


public class TokenGate721 : MonoBehaviour
{
    // Replace with the custom contract address if needed
    private string customContractAddress = "ContractAddressHere";


    // Create a new ERC721 object
    ERC721 myToken;


    async void Start()
    {
        // Instantiate a new instance of the ERC721 object
        myToken = new ERC721(customContractAddress);


        BigInteger tokenIdToCheck = 123; // Replace with the token ID you want to check


        // Fetch the owner of the ERC-721 token
        string tokenOwner = await myToken.OwnerOf(tokenIdToCheck);


        if (tokenOwner == PlayerPrefs.GetString("Account"))
        {
            Debug.Log("The player owns this token");


            // Implement remaining logic here
        }
        else
        {
            Debug.Log("The player does not own this token");


            // Implement remaining logic here
        }
    }
}

Here’s what’s happening:

  • The customContractAddress variable holds the address of your ERC-721 smart contract. Ensure that you replace "ContractAddressHere" with the actual address.

  • In the Start method, we specify the tokenIdToCheck, which is the ID of the ERC-721 token we want to check for ownership.

  • We use the ERC721.OwnerOf method to asynchronously fetch the owner of the specified ERC-721 token. This method communicates with the Ethereum blockchain to retrieve ownership information.

  • The code then checks if the fetched tokenOwner matches the player’s Ethereum account address stored in PlayerPrefs. If they match, it indicates that the player owns the token, and relevant logic can be executed.

  • Depending on the ownership status, you can customize the logic within the if and else blocks. For instance, you can grant access to specific in-game features or assets if the player owns the token.

Fetching ERC-1155 Token Owner

using System;
using System.Numerics;
using System.Threading.Tasks;


public class TokenGate1155 : MonoBehaviour
{
    // Replace with the custom contract address if needed
    private string customContractAddress = "ContractAddressHere";


    // Create a new ERC1155 object
    ERC1155 myToken;


    async void Start()
    {
        BigInteger tokenIdToCheck = 123; // Replace with the token ID you want to check
        string playerAddress = "0xYourPlayerAddress"; // Replace with the player's address


        // Fetch the balance of the ERC-1155 token for the player
        BigInteger tokenBalance = await myToken.BalanceOf(playerAddress, tokenIdToCheck);


        if (tokenBalance > 0)
        {
            // The player owns one or more tokens of the specified ID


            // Implement logic for granting access or abilities
        }
        else
        {
            // The player does not own any tokens of the specified ID


            // Implement alternative logic
        }
    }
}

Here’s what’s happening:

  • The customContractAddress variable holds the address of your ERC-1155 smart contract. Ensure that you replace "ContractAddressHere" with the actual address.

  • In the Start method, we specify the tokenIdToCheck, which is the ID of the ERC-1155 token we want to check for ownership. Additionally, playerAddress holds the Ethereum address of the player whose ownership we want to check.

  • We use the ERC1155.BalanceOf method to asynchronously fetch the balance of the specified ERC-1155 token for the player. This method interacts with the Ethereum blockchain to retrieve the token balance.

  • The code checks if the fetched tokenBalance is greater than 0, indicating that the player owns one or more tokens of the specified ID. If this condition is met, you can implement logic for granting access or abilities to the player.

  • If the tokenBalance is 0, it means the player does not own any tokens of the specified ID. You can implement alternative logic based on this condition.

These code examples demonstrate how you can use Eidolon to fetch ownership information of ERC-721 and ERC-1155 tokens within Unity. You can then implement game logic based on token ownership, granting access, abilities, or other in-game benefits accordingly.