Part 1: How to Create an NFT Game Smart Contract

$
node -v

$
mkdir alchemon && cd alchemon
>
npm init -y
>
npm install --save-dev hardhat
>
npx hardhat

$
npx hardhat test

$
npm install @openzeppelin/contracts

1
// SPDX-License-Identifier: MIT
2
pragma solidity ^0.8.9;
3
4
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
5
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
6
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
7
import "@openzeppelin/contracts/access/Ownable.sol";
8
import "@openzeppelin/contracts/utils/Counters.sol";
9
import "@openzeppelin/contracts/utils/Base64.sol";
10
import "@openzeppelin/contracts/utils/Strings.sol";
11
12
contract AlchemonNft is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
13
    using Counters for Counters.Counter;
14
15
    Counters.Counter private _tokenIds;
16
17
    // Set price for the genesis NFTs
18
    uint public constant PRICE = 0.0005 ether;
19
20
    constructor() ERC721("Alchemon", "Alch") {}
21
22
    // Mint Genesis NFTs
23
    function mintGenesis(uint _count) public payable {
24
        require(msg.value >= PRICE, "Not enough ether to purchase genesis NFT.");
25
26
        // Genesis NFTs are generation 0
27
        for (uint i = 0; i < _count; i++) {
28
            string memory metadata = generateMetadata(_tokenIds.current(), 0);
29
            _mintSingleNft(metadata);
30
        }
31
        
32
    }
33
34
    // Generate NFT metadata
35
    function generateMetadata(uint tokenId, uint generation) public pure returns (string memory) {
36
        string memory svg = string(abi.encodePacked(
37
            "<svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinyMin meet' viewBox='0 0 350 350'>",
38
            "<style>.base { fill: white; font-family: serif; font-size: 25px; }</style>",
39
            "<rect width='100%' height='100%' fill='blue' />",
40
            "<text x='50%' y='40%' class='base' dominant-baseline='middle' text-anchor='middle'>",
41
            "<tspan y='40%' x='50%'>Alchemon #",
42
            Strings.toString(tokenId),
43
            "</tspan>",
44
            "<tspan y='50%' x='50%'>Generation ",
45
            Strings.toString(generation),
46
            "</tspan></text></svg>"
47
        ));
48
49
        string memory json = Base64.encode(
50
            bytes(
51
                string(
52
                    abi.encodePacked(
53
                        '{"name": "Alchemon #',
54
                        Strings.toString(tokenId),
55
                        '", "description": "An in-game monster", "image": "data:image/svg+xml;base64,',
56
                        Base64.encode(bytes(svg)),
57
                        '", "attributes": [{"trait_type": "Generation", "value": "',
58
                        Strings.toString(generation),
59
                        '"}]}'
60
                    )
61
                )
62
            )
63
        );
64
65
        string memory metadata = string(
66
            abi.encodePacked("data:application/json;base64,", json)
67
        );
68
69
        return metadata;
70
    }
71
72
    // Breed a new NFT
73
    function breed(uint parent1Id, uint parent2Id) public {
74
        require(parent1Id != parent2Id, "Parents must be different");
75
        require(ownerOf(parent1Id) == msg.sender && ownerOf(parent2Id) == msg.sender, "Sender doesn't own NFTs");
76
77
        // Get generations of each parent and compute new generation
78
        // New Generation = Max(Parent 1, Parent 2) + 1
79
        uint newGen;
80
81
        if (parent1Id >= parent2Id) {
82
            newGen = parent1Id + 1;
83
        } else {
84
            newGen = parent2Id + 1;
85
        }
86
87
        // Generate metadata
88
        string memory metadata = generateMetadata(_tokenIds.current(), newGen);
89
90
        // Mint offspring
91
        _mintSingleNft(metadata);
92
    }
93
94
    // Mint a single NFT with on-chain metadata
95
    function _mintSingleNft(string memory _tokenURI) private {
96
        uint newTokenID = _tokenIds.current();
97
        _safeMint(msg.sender, newTokenID);
98
        _setTokenURI(newTokenID, _tokenURI);
99
        _tokenIds.increment();
100
    }
101
102
    // Get tokens of an owner
103
    function tokensOfOwner(address _owner) external view returns (uint[] memory) {
104
105
        uint tokenCount = balanceOf(_owner);
106
        uint[] memory tokensId = new uint256[](tokenCount);
107
108
        for (uint i = 0; i < tokenCount; i++) {
109
            tokensId[i] = tokenOfOwnerByIndex(_owner, i);
110
        }
111
        return tokensId;
112
    }
113
114
    // Withdraw ether
115
    function withdraw() public payable onlyOwner {
116
        uint balance = address(this).balance;
117
        require(balance > 0, "No ether left to withdraw");
118
119
        (bool success, ) = (msg.sender).call{value: balance}("");
120
        require(success, "Transfer failed.");
121
    }
122
123
    // The following functions are overrides required by Solidity.
124
125
    function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
126
        internal
127
        override(ERC721, ERC721Enumerable)
128
    {
129
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
130
    }
131
132
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage) {
133
        super._burn(tokenId);
134
    }
135
136
    function tokenURI(uint256 tokenId)
137
        public
138
        view
139
        override(ERC721, ERC721URIStorage)
140
        returns (string memory)
141
    {
142
        return super.tokenURI(tokenId);
143
    }
144
145
    function supportsInterface(bytes4 interfaceId)
146
        public
147
        view
148
        override(ERC721, ERC721Enumerable)
149
        returns (bool)
150
    {
151
        return super.supportsInterface(interfaceId);
152
    }
153
}

$
npx hardhat compile

1
require("@nomicfoundation/hardhat-toolbox");
2
3
/** @type import('hardhat/config').HardhatUserConfig */
4
module.exports = {
5
  solidity: "0.8.17",
6
  networks: {
7
    goerli: {
8
      url: '<-- ALCHEMY APP HTTP URL -->',
9
      accounts: ['<-- METAMASK WALLET PRIVATE KEY -->']
10
    }
11
  }
12
};

1
const hre = require("hardhat");
2
const ethers = require("ethers");
3
4
async function main() {
5
6
  // Deploy the Alchemon contract
7
  const contractFactory = await hre.ethers.getContractFactory('AlchemonNft');
8
  const alchContract = await contractFactory.deploy();
9
  await alchContract.deployed();
10
11
  console.log("Contract deployed to:", alchContract.address);
12
13
  // Mint 2 genesis NFTs
14
  let txn;
15
  txn = await alchContract.mintGenesis(2, { value: ethers.utils.parseEther('0.001') });
16
  await txn.wait();
17
  console.log("2 NFTs minted");
18
19
  // Breed genesis NFTs
20
  txn = await alchContract.breed(0, 1);
21
  await txn.wait();
22
  console.log("1 NFT bred");
23
24
}
25
26
const runMain = async () => {
27
  try {
28
    await main();
29
    process.exit(0);
30
  } catch (e) {
31
    console.log(e);
32
    process.exit(1);
33
  }
34
}
35
36
runMain();

$
npx hardhat run scripts/deploy.js --network goerli