TLDR:

• This tutorial showcases how to create an ERC-721 “Polyland” contract on Harmony devnet that treats each land patch as an NFT.
• Polyland can hold a finite set of triangular patches, and the owner (contract deployer) can mint them to different accounts until the supply is capped.
• Foundry is used to compile and deploy the contract, then the Harmony explorer is used to verify it and distribute patches.
• Once deployed, each patch’s owner and properties (triangle edges) can be queried on-chain, illustrating the fundamentals of a metaverse asset contract.

​

Main article

The blockchain part of any metaverse that involves decentralization is object ownership.

On Harmony, object ownership can be realized with the HRC-721 token standard, commonly known as NFT.

A very basic example of realizing a metaverse on blockchain is creating a plot of land and distributing the patches of it to different owners—all through an NFT contract.

In this tutorial, you will:

• Create a simple contract called Polyland. The Polyland contract represents a plot of land.
• Program Polyland to consist of patches of land.
• Deploy Polyland on the Harmony devnet through a node deployed with Chainstack.
• Distribute patches of Polyland to different accounts on the Harmony devnet.

​

Prerequisites

• Chainstack account to deploy a Harmony node.
• Foundry to create and deploy contracts.

​

Overview

To get from zero to a deployed metaverse contract and patches of land distributed on the Harmony devnet, do the following:

​

Step-by-step

​

Create a public chain project

See Create a project.

​

Join the Harmony devnet

See Join a public network.

​

Get your Harmony node access and credentials

See View node access and credentials.

​

Install Foundry

See Foundry.

​

Create the contract

forge init polyland

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Polyland is ERC721, Ownable {
    using Counters for Counters.Counter;

    Counters.Counter private supply;

    uint256 public maxSupply = 4;

    struct Triangle {
        string name;
        int8 edge1;
        int8 edge2;
        int8 edge3;
    }

    Triangle[] public triangles;

    constructor() ERC721("Polyland", "PLLND") {
    triangles.push(Triangle("Triangle0", 0,0,0));
    triangles.push(Triangle("Triangle1", 1,1,1));
    triangles.push(Triangle("Triangle2", 2,2,2));
    triangles.push(Triangle("Triangle3", 3,3,3));
    triangles.push(Triangle("Triangle4", 4,4,4));
    }

    modifier supplyCap {
      require(supply.current() <= maxSupply, "All patches minted.");
      _;
    }

    function totalSupply() public view returns (uint256) {
      return supply.current();
    }

    function getTriangles() public view returns (Triangle[] memory) {
      return triangles;
    }

    function mintTriangle(address account)
        public
        onlyOwner
        supplyCap
        returns (uint256)
    {
        supply.increment();

        uint256 newPatchId = supply.current();
        _mint(account, newPatchId);

        return newPatchId;
    }
}

forge install openzeppelin/openzeppelin-contracts

@openzeppelin/=lib/openzeppelin-contracts/

forge flatten polyland.sol > polylandFlat.sol

forge create Polyland --contracts /root/polyland/src/polylandFlat.sol --private-key YOUR_PRIVATE_KEY --rpc-url YOUR_CHAINSTACK_ENDPOINT --
legacy

​

Verify the contract

This will verify the contract. You can now use the explorer as a web app to interact with the contract.

​

Distribute the patches of land

1. On the contract page in the Harmony Testnet explorer, click Write Contract.
2. In mintTriangle, provide an address to distribute a patch of land to. Distribute the patches to different addresses until you hit the cap with the All patches minted message.
3. On the Read Contract tab, query the ownerOf field by putting in the tokenId values representing each of the patches of land: 1, 2, 3, 4.
4. In the triangles field, put in the same tokenId values to get the data on each of the patches: name and the size of each of the three edges.

​

Conclusion

This tutorial guided you through the basics of creating and deploying a metaverse contract with object ownership representation.

You created your own plot of land, distributed the finite number of land patches to different owners, and retrieved the data for each of the patches: patch size and patch owner.

You did all of it using Foundry.

This tutorial uses devnet, however, the exact same instructions and sequence work on the mainnet.

​

About the author

Ake

Developer Advocate @ Chainstack

Talk to me all things Web3

20 years in technology | 8+ years in Web3 full time years experience

Trusted advisor helping developers navigate the complexities of blockchain infrastructure