ERC-721 implementation in Blockchain / Solidity - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the contract inherits from the OpenZeppelin ERC721 standard.

Blockchain / Solidity

contract MyNFT is [1] {
    constructor() ERC721("MyNFT", "MNFT") {}
}

Drag options to blanks, or click blank then click option'

AERC721

BERC20

COwnable

DIERC20

Attempts:

3 left

💡 Hint

Common Mistakes

Using ERC20 instead of ERC721

Not inheriting any contract

The contract must inherit from ERC721 to implement the NFT standard.

2fill in blank

medium

Complete the function to mint a new token to the given address.

Blockchain / Solidity

function mintNFT(address to, uint256 tokenId) public {
    _[1](to, tokenId);
}

Drag options to blanks, or click blank then click option'

Amint

BsafeMint

CtransferFrom

DsafeTransferFrom

Attempts:

3 left

💡 Hint

Common Mistakes

Using mint instead of _safeMint

Using transfer functions to mint

_safeMint safely mints a new token and checks if the receiver can handle NFTs.

3fill in blank

hard

Fix the error in the function that returns the token URI.

Blockchain / Solidity

function tokenURI(uint256 tokenId) public view override returns (string memory) {
    require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
    return string(abi.encodePacked(_baseURI(), [1]));
}

Drag options to blanks, or click blank then click option'

AStrings.toString(tokenId)

BtoString(tokenId)

CtokenId

Duint2str(tokenId)

Attempts:

3 left

💡 Hint

Common Mistakes

Using tokenId directly (uint) in string concatenation

Using undefined conversion functions

The Strings.toString function converts the tokenId to a string for URI concatenation.

4fill in blank

hard

Fill both blanks to define a mapping and a function to check token ownership.

Blockchain / Solidity

mapping(uint256 => address) private [1];

function ownerOf(uint256 tokenId) public view override returns (address) {
    address owner = [2][tokenId];
    require(owner != address(0), "ERC721: owner query for nonexistent token");
    return owner;
}

Drag options to blanks, or click blank then click option'

A_owners

Bowners

DtokenOwners

Attempts:

3 left

💡 Hint

Common Mistakes

Using different names for mapping and access

Using public instead of private mapping

The standard ERC721 implementation uses a private mapping named _owners to track token owners.

5fill in blank

hard

Fill all three blanks to implement a function that safely transfers a token.

Blockchain / Solidity

function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override {
    require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: caller is not token owner nor approved");
    [1](from, to, tokenId, data);
}

function [2](address from, address to, uint256 tokenId, bytes memory data) internal {
    _transfer(from, to, tokenId);
    require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
}

function [3](address from, address to, uint256 tokenId) internal {
    // actual transfer logic here
}

Drag options to blanks, or click blank then click option'

A_safeTransfer

C_transfer

D_transferFrom

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up function names

Calling transfer instead of safeTransfer

The public function calls _safeTransfer, which calls _transfer to move the token.

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