ERC-721 implementation in Blockchain / Solidity - Mini Project: Build & Apply

Basic ERC-721 NFT Contract

📖 Scenario: You want to create a simple NFT (Non-Fungible Token) contract on Ethereum. NFTs are unique digital items like collectibles or art. ERC-721 is the standard interface for NFTs.In this project, you will build a basic ERC-721 contract that can mint unique tokens and keep track of their owners.

🎯 Goal: Build a simple ERC-721 contract named SimpleNFT that allows minting unique tokens with IDs and stores ownership information.

📋 What You'll Learn

Create a contract named SimpleNFT that inherits from OpenZeppelin's ERC721.

Add a constructor that sets the token name to SimpleNFT and symbol to SNFT.

Create a public function mintNFT that takes an address recipient and a uint256 tokenId and mints a new token to the recipient.

Use OpenZeppelin's ERC721 implementation for standard NFT behavior.

💡 Why This Matters

🌍 Real World

NFTs are used for digital art, collectibles, gaming items, and more. This contract is a simple foundation for creating unique digital assets on Ethereum.

💼 Career

Understanding ERC-721 is essential for blockchain developers working on NFT projects, marketplaces, or decentralized applications involving unique tokens.

1

Set up the contract and import ERC721

Write the Solidity code to declare a contract named SimpleNFT that imports OpenZeppelin's ERC721 contract from @openzeppelin/contracts/token/ERC721/ERC721.sol.

Blockchain / Solidity

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

// Import ERC721 from OpenZeppelin
// Your code here

Hint

Use import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; and declare contract SimpleNFT is ERC721.

2

Add constructor to set name and symbol

Add a constructor to SimpleNFT that calls the ERC721 constructor with the name "SimpleNFT" and symbol "SNFT".

Blockchain / Solidity

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract SimpleNFT is ERC721 {
    // Add constructor here
    // Your code here
}

Hint

Use constructor() ERC721("SimpleNFT", "SNFT") {} to set the token name and symbol.

3

Create mintNFT function to mint tokens

Add a public function named mintNFT that takes address recipient and uint256 tokenId as parameters and calls _mint(recipient, tokenId) to mint the token.

Blockchain / Solidity

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract SimpleNFT is ERC721 {
    constructor() ERC721("SimpleNFT", "SNFT") {}

    // Add mintNFT function here
    // Your code here
}

Hint

Define function mintNFT(address recipient, uint256 tokenId) public and call _mint(recipient, tokenId); inside it.

4

Test minting by calling mintNFT

Write a comment line showing how to call mintNFT to mint token ID 1 to address 0x1234567890123456789012345678901234567890.

Blockchain / Solidity

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

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract SimpleNFT is ERC721 {
    constructor() ERC721("SimpleNFT", "SNFT") {}

    function mintNFT(address recipient, uint256 tokenId) public {
        _mint(recipient, tokenId);
    }
}

// Call mintNFT to mint token ID 1 to address 0x1234567890123456789012345678901234567890
// Your code here

Hint

Write a comment showing the call: simpleNFT.mintNFT(0x1234567890123456789012345678901234567890, 1);

Practice

1.

What is the main purpose of the ERC-721 standard in blockchain?

easy

A. To create fungible tokens like cryptocurrencies

B. To manage smart contract ownership

C. To create unique, non-fungible tokens (NFTs)

D. To enable fast transaction processing

Solution

1. Step 1: Understand ERC-721 token type

   ERC-721 defines a standard for unique tokens, unlike fungible tokens which are identical.

2. Step 2: Identify the purpose of ERC-721

   It is used to create NFTs, which are unique digital assets on the blockchain.

3. Final Answer:

   To create unique, non-fungible tokens (NFTs) -> Option C

4. Quick Check:

   ERC-721 = Unique NFTs [OK]

Hint: ERC-721 is for unique tokens, not identical ones [OK]

Common Mistakes:

• Confusing ERC-721 with ERC-20 fungible tokens
• Thinking ERC-721 manages contract ownership
• Assuming ERC-721 speeds up transactions

2.

Which of the following is the correct way to inherit OpenZeppelin's ERC721 contract in Solidity?

contract MyNFT is ? {}

easy

A. SafeMath

B. ERC721

C. Ownable

D. ERC20

Solution

1. Step 1: Identify the correct base contract for NFTs

   ERC721 is the OpenZeppelin contract for NFTs, ERC20 is for fungible tokens.

2. Step 2: Confirm inheritance syntax

   Using is ERC721 correctly inherits the NFT functionality.

3. Final Answer:

   ERC721 -> Option B

4. Quick Check:

   Inherit ERC721 for NFTs [OK]

Hint: Use ERC721 to inherit NFT features [OK]

Common Mistakes:

• Using ERC20 instead of ERC721
• Confusing Ownable with ERC721
• Trying to inherit SafeMath for NFTs

3.

What will be the output of the following Solidity function when called?

function mintToken(address to, uint256 tokenId) public {
    _mint(to, tokenId);
}

// Assume _mint works as expected and tokenId = 1, to = 0x123...

What happens after calling mintToken(0x123..., 1)?

medium

A. A new NFT with tokenId 1 is assigned to address 0x123...

B. The tokenId 1 is burned from address 0x123...

C. The function throws a syntax error

D. The tokenId 1 is transferred from 0x123... to the caller

Solution

1. Step 1: Understand the _mint function

   _mint creates a new token with the given tokenId and assigns it to the 'to' address.

2. Step 2: Analyze the function call

   Calling mintToken with address 0x123... and tokenId 1 creates that NFT for 0x123....

3. Final Answer:

   A new NFT with tokenId 1 is assigned to address 0x123... -> Option A

4. Quick Check:

   mintToken creates NFT for 'to' address [OK]

Hint: _mint assigns new token to given address [OK]

Common Mistakes:

• Thinking _mint burns tokens
• Assuming _mint transfers tokens
• Expecting syntax errors from correct code

4.

Identify the error in this Solidity snippet for minting an ERC-721 token:

function mint(address to, uint256 tokenId) public {
    _mint(tokenId, to);
}

medium

A. Function must be named mintToken, not mint

B. _mint cannot be called inside a public function

C. tokenId must be a string, not uint256

D. _mint parameters are reversed; should be (to, tokenId)

Solution

1. Step 1: Check _mint function parameter order

   OpenZeppelin's _mint expects (address to, uint256 tokenId).

2. Step 2: Compare with given code

   The code uses _mint(tokenId, to), reversing the parameters.

3. Final Answer:

   _mint parameters are reversed; should be (to, tokenId) -> Option D

4. Quick Check:

   _mint(to, tokenId) correct order [OK]

Hint: _mint needs (address, tokenId) order [OK]

Common Mistakes:

• Swapping parameters of _mint
• Thinking _mint can't be public
• Confusing tokenId type

5.

You want to create an ERC-721 contract that only allows the contract owner to mint new tokens. Which of these Solidity code snippets correctly enforces this?

contract MyNFT is ERC721, Ownable {
    function mint(address to, uint256 tokenId) public {
        ?
        _mint(to, tokenId);
    }
}

hard

A. require(msg.sender == owner(), "Not owner");

B. require(to == owner(), "Not owner");

C. require(tokenId > 0, "Invalid tokenId");

D. require(msg.sender != owner(), "Owner cannot mint");

Solution

1. Step 1: Understand ownership check

   Only the contract owner should mint, so check if msg.sender equals owner().

2. Step 2: Analyze each require statement

   require(msg.sender == owner(), "Not owner"); correctly checks sender is owner; others check wrong conditions.

3. Final Answer:

   require(msg.sender == owner(), "Not owner"); -> Option A

4. Quick Check:

   Owner check uses msg.sender == owner() [OK]

Hint: Check msg.sender equals owner() before minting [OK]

Common Mistakes:

• Checking 'to' address instead of sender
• Allowing anyone to mint without checks
• Using wrong require conditions