The ERC-404 token has been the talk of the town lately, which means now is the perfect time to explore it at length. This course has been designed keeping in mind the ERC-404 token standard. First, it will give you an overview of building an NFT marketplace using the DN404 standard. Then, you will build your token using DN404. Thirdly, you will build the marketplace and use it to buy or sell your share of tokens. Lastly, you will prepare the front-end which will allow you to interact with the NFT marketplace contract.

A free and practical course that teaches you how to build a marketplace for semi-fungible ERC-404 tokens via hands-on learning. Enroll now.

Build a Semi-Fungible ERC404 Tokens' Marketplace

# What Are We Building Today

GM everyone ☀ ️, today we are very excited to bring the first-ever detailed course about the ERC404 and DN404 token standards for developers on Metaschool.

So, what are we building today? We are going to build the NFT Marketplace for the DN404 token which offers the versatile implementation of the ERC404 token standard. 

Now, what’s the hype? At the start of 2024, the PANDORA coin was released which was based on the ERC404 token standard. Pandora aimed to increase the liquidity for NFTs by combining both ERC20 and ERC721 token standards.

![intro-1 (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/1%20Getting%20Started/1%20What%20Are%20We%20Building%20Today/intro-1_(1).png?raw=true)

Within a week of its release, it went from $250 to $32,000 price. In upcoming days it is estimated that it will go even higher from this point.

So, it is high time we learn a new token standard that is getting a lot of traction only in the early days.

## Course overview

Before we get started with the content, let me give you an overview of what we will be covering:

1. Deep dive into the ERC404 token standard
2. Deep dive into the DN404 token standard
3. Implementation of our unique token using the DN404 token standard
4. Building the NFT marketplace for DN404 token

## Who exactly should take this course?

This course is for intermediate web3 developers who wish to learn about the ERC404 token standard. Don’t worry if you are not experienced with Solidity, We’ve got your back. Anyways it's good to have a basic knowledge of blockchain, ERC20 and ERC721 token standards, and basic level Solidity.

## Proof of completion

Well, I'm glad to spill the beans here. After you complete this course with me, you will get XPs and a special NFT, which will unlock many more opportunities on the Metaschool platform. Here is a sneak peek of what the NFT will look like below.

![https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/course%20NFT.gif?raw=true](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/course%20NFT.gif?raw=true)

Now before we move forward, let’s set some house rules first.

1. Pleaseeeee do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. Stay happy and positive!

Alright guys, no need to wait any longer, let's dive right into our awesome ERC404 course! Let's do this! 🙌

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/1%20Getting%20Started/1%20What%20Are%20We%20Building%20Today.md

What Are We Building Today

# What the Hell Is the ERC404?

Welcome back! Today, we are going to explore the curious case of the ERC404 token. Let's dive into what it is, how it works, and its impact on the real world.

## Let's revise what ERC20 and ERC721 tokens are

First, let’s start by discussing two main token standards on the Ethereum blockchain: ERC20 and ERC721 tokens.

ERC20 tokens are fungible tokens that function like traditional currency. They are the equivalent of a dollar in the Ethereum ecosystem that you can hold in your digital wallet and are commonly used as a gas price for everyday transactions.

On the other hand, ERC721 tokens are non-fungible tokens (NFTs) that are highly valued based on their uniqueness and collectible value. Each NFT is one-of-a-kind and cannot be exchanged for another NFT.

While these tokens are very different, they can be bought and sold with each other. However, you can only buy entire NFTs with fungible tokens, as there is no way to buy only a portion of an NFT.

This is where the ERC404 token comes in. What is it, you may ask? Stay tuned!

## So, what the hell is the ERC404 token?

The ERC404 token is a unique token that combines both ERC20 and ERC721 token features. It aims to blend the best features of both token standards and propose innovation to the NFTs. With this innovation, multiple wallets can own shares of a single NFT piece from a collection.

![intro-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/1%20Getting%20Started/2%20What%20the%20Hell%20Is%20the%20ERC404/intro-1.png?raw=true)

This token is experimental and can be either a fungible or non-fungible token based on its implementation. Let me explain this with multiple examples.

### Example #1

If you decide to create a fungible token using the ERC404 token standard, it will be interchangeable with other tokens of the same kind without any loss of value. Once the token has been used or redeemed, it can be transformed into an NFT, which possesses unique and collectible qualities. 

Think of it like this — there is a coin from the 20BC century. In the 20BC century, it was used to exchange goodies, but now it is worth a lot more and stored in a museum for everyone to look at and get inspired.

### Example #2

On the other hand, if you create an NFT using the ERC404 token standard, it can be divided into multiple smaller units that can be traded as fungible tokens. When the divided units are recombined, it becomes an NFT again.

Think of it like this — there is a unique digital artwork that can be divided into pieces, where an individual token represents each piece. Each piece can be co-owned by multiple people, and each individual can trade their piece just like any other tradable asset. 

This approach makes it easier for NFTs to reach a wider audience and increase their liquidity.

Isn't this exciting?

Now, let’s dive into a bit more of the technical aspects of the ERC404 token standard.

## How does the ERC404 token standard work?

ERC404 allows fractional ownership by linking the tokens (every issued token) with a specific NFT. This type of linking allows NFT to have multiple owners based on the share of tokens they will have. Each NFT can have a base unit that defines the minimum amount of linked tokens that can be transferred, held, or exchanged with anyone. This enables the widespread distribution of a single NFT, increasing the liquidity of both the NFT and the token.

Let’s take an example to understand this better.

### Example

Consider an NFT named "Artistic Ape" that represents the ERC404 token. This token is referred to as an "APtoken" and is divisible into 100 fractions, with each fraction representing 1% of the NFT. To own the APtoken completely, you would need to own all 100 tokens.


![intro-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/1%20Getting%20Started/2%20What%20the%20Hell%20Is%20the%20ERC404/intro-2.png?raw=true)

### ERC404 token standard contract implementation

ERC404 token contract have several functionalities, but four main functions help us create the token from end to end. Let’s discuss them using our APtoken example.

1. **Mint:** To own our "Artistic Ape" NFT, token ownership begins with the minting of tokens. The token creator issues new tokens for APtoken, up to a supply chain of 100 fractions. For instance, if you decide to buy all 100 fractions of the NFT, the creator will mint your tokens and you will have complete ownership of the NFT.
2. **Burn:** By using the burn function, you can reduce the total supply of your APtokens by burning some amount of tokens.
3. **Transfer:** If you choose to sell your tokens, you can transfer them to anyone using the transfer function. The function will first verify if you are the owner of the APtoken, and then it will change the ownership of your "Artistic Ape" NFT.
4. **BatchTransfer:** What if you have multiple buyers of your APtoken? Transferring the tokens to them individually will be a hassle. The **BatchTransfer** function enables you to transfer fractions of tokens to multiple addresses in a single transaction and modify the ownership of your "Artistic Ape" NFT.

## Let’s summarize

ERC404 is a very versatile token standard that manages NFTs (non-fungible tokens) very effectively. With this standard, you can link tokens with NFTs and divide the NFT into smaller fractions, with each fraction represented by a token. These tokens can be easily bought, sold, or traded with other kinds of tokens, which makes the NFTs more accessible and increases their liquidity. Furthermore, the minting mechanism ensures that the owners of the token fractions are kept up-to-date, making ERC404 a secure and reliable token standard.

You can find the Pandora ERC404 implementation [here](https://github.com/Pandora-Labs-Org/erc404).

## That’s a wrap

ERC404 token is again revolutionizing the crypto world. If you deeply develop its understanding, you can build your own ERC404 token and launch it on the chain just like the PANDORA token. But it surely does have some shortcomings. Let’s discuss them in the next lesson and introduce you to the DN404 token standard.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/1%20Getting%20Started/2%20What%20the%20Hell%20Is%20the%20ERC404.md

What the Hell Is the ERC404?

# What the Hell Is the DN404?

We’re so proud of you for covering all about the ERC404 token standard. Now, we will explore the shortcomings of ERC404 and get to know about the DN404 in detail.

## ERC404 hype

You must have heard of the statement that with great responsibility comes a great price. This is what happened with the ERC404. ERC404 hype caused the high gas fees among the Ethereum  ecosystem which made it even more difficult for developers like you and us to create the custom ERC20 tokens.

![dn404-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/1%20Getting%20Started/3%20What%20the%20Hell%20Is%20the%20DN404/dn404-1.png?raw=true)

This is where the DN404 came into the picture. Out of frustration and to resolve the gas fees issue, a group of developers introduced “Divisible NFT-404” token (DN404).

![dn404-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/1%20Getting%20Started/3%20What%20the%20Hell%20Is%20the%20DN404/dn404-2.png?raw=true)

DN404 is built upon the established and up to date ERC20 and ERC721 tokens. It introduce the better approach to manage the user balance and NFTs seperately. This setup promises a smoother experience for users and more efficient handling of tokens.

## How does the DN404 work?

DN404 offers almost 20% reduction in gas fees. The DN404 differs from ERC404 in the contract structure. The ERC404 merge the ERC20 and ERC721 tokens standard functionalities into the one contract. While, DN404 uses two separate contracts for a standard ERC20 token and a mirrored ERC721 token. However, the developers argue that this approach will cause the security risk.

However, both ERC404 and DN404, are experimental tokens. Both are not approved by Ethereum as official standards.

## That’s a wrap

In this course, we will use the DN404 to implement the token and create a marketplace for it. So, stay tuned and start building! 

In the next lesson, we will setup the development environment and install important dependencies.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/1%20Getting%20Started/3%20What%20the%20Hell%20Is%20the%20DN404.md

What the Hell Is the DN404?

Profsain

jack

carmy

Getting Started

# Set Up the Hardhat Project

Greetings folks! Great work on understanding all about the ERC404 token. You have been doing so awesome. Now, we will dive into the development and start setting up our development environment.

So what are you waiting for? Let’s start setting up our hardhat project.

## Prerequisites

First, we need a few installations. So, make sure you have the following on your machine:

- A code editor (we are using [Visual Studio](https://code.visualstudio.com/download).)
- [Install Node.js](https://nodejs.org/en/download) (Please make sure to install `v18` for this project. We are using `v18.17.1`. It is important to use the appropriate version to avoid facing errors.)
- [Install GitHub](https://github.com/git-guides/install-git)
- Install the [MetaMask Chrome extension](https://chromewebstore.google.com/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn).

## Clone the boilerplate Hardhat project

To save you some work, we created a npm project with Hardhat configuration files. Open the terminal and run the following command to clone the GitHub repository. 

```
git clone https://github.com/0xmetaschool/erc404-nftmarketplace-boilerplate.git
```

Now, run the following commands one by one to move to the repository folder and install all dependencies:

```
cd erc404-nftmarketplace-boilerplate
npm install dotenv --save --force
npm install --save-dev hardhat --force
npm install --force
```

When you install the dependencies, you will receive different warnings. Please ignore those warnings and move forward. Here is an example output of the `npm install --force` command.

![setup-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/2%20Prerequisites%20to%20Building%20the%20MarketPlace/1%20Set%20Up%20the%20Hardhat%20Project/struct-1.1.png?raw=true)

**Note:** If you are planning to not use the boilerplate project and create your own Hardhat project, please make sure that you are using the same config file and copying other important files from the `contracts` folder.

## Project structure

Here’s how your complete hardhat project structure will look like.

![setup-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/2%20Prerequisites%20to%20Building%20the%20MarketPlace/1%20Set%20Up%20the%20Hardhat%20Project/setup-2.png?raw=true)

## That’s a wrap

You cloned the basic boilerplate hardhat project from GitHub. Now you are ready to move onto next step of doing a few tasks that’ll help us in deployment of our dApp.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/2%20Prerequisites%20to%20Building%20the%20MarketPlace/1%20Set%20Up%20the%20Hardhat%20Project.md

Set Up the Hardhat Project

# Set Up Wallet

Greetings folks! Great work coming this far. Now, we will dive into setting up a few things so stay with us!

## MetaMask

We need a wallet to proceed so if you have not installed MetaMask, just install the [MetaMask Chrome extension](https://chromewebstore.google.com/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn). 

## Setting up the testnet environment

Next, we will opt for the Mumbai network to deploy our code. To set it up, complete the following steps:

- Head over to [https://chainlist.org/chain/80001](https://chainlist.org/chain/80001).
- Click on “Connect Wallet”.
- Click on Next, then Connect, then Approve, and finally Switch Network.
- After connecting your wallet, click on “Add to Metamask”.
- Click on Approve and then Switch Network.

You will be successfully connected to the Mumbai network. See in the following gif how I did it:

![Screen Recording 2023-08-02 at 7.19.24 PM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/2%20Prerequisites%20to%20Building%20the%20MarketPlace/2%20Set%20Up%20Wallet/Screen_Recording_2023-08-02_at_7.19.24_PM.gif?raw=true)

### Get some fake MATIC $$ 🤑

Now it's time to get some money! 

- Copy your account address.
- Head over to [https://faucet.polygon.technology/](https://faucet.polygon.technology/).
- Paste your wallet address.

See in the following gif how I did it:

![Frame 3560365 (7).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/2%20Prerequisites%20to%20Building%20the%20MarketPlace/2%20Set%20Up%20Wallet/Frame_3560365_(7).gif?raw=true)

This fake money will be used for deploying your contract and doing transactions on your contract. This is not real money, you can’t buy NFTs, or other assets via these MATIC.

## Get your private 🦊 MetaMask key

While writing and deploying your contract you sign off each contract with your private key to tell the blockchain that you are a legit person creating a real transaction. Complete the following steps to find your private key:

- Open the Metamask extension.
- Click on your Account.
- Click on 3 dots and then Account Details.
- Click on “Show private key”.
- Enter your password and hit Confirm.
- Copy your private key.

See in the following gif how I did it:

![Screen Recording 2023-08-02 at 7.28.24 PM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/2%20Prerequisites%20to%20Building%20the%20MarketPlace/2%20Set%20Up%20Wallet/Screen_Recording_2023-08-02_at_7.28.24_PM.gif?raw=true)

Your private key is super important and should be secured. So be extra vigilant in keeping it that way. Next, I’ll tell you how to keep your account and private key safe.

## Create `.env` file

Now create a `.env` file in your folder of `erc404-nftmarketplace-boilerplate` and paste the following into the file. Yes. Your file name would be `.env`! Replace `<YOUR_PRIVATE_KEY>` with the one you copied from your Metamask.

```
PRIVATE_KEY=<YOUR_PRIVATE_KEY>
```

## That’s a wrap

You have set up your environment. Now you are ready to build the marketplace and work with the DN404 contract that we have already added for you in our boilerplate project.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/2%20Prerequisites%20to%20Building%20the%20MarketPlace/2%20Set%20Up%20Wallet.md

Set Up Wallet

Tomas

Qipmunk

Prerequisites to Building the MarketPlace

# Build the Token - I

Welcome back, folks! Great work on setting up your hardhat project. In this lesson, we will create the token using the DN404 token standard. This token will play the part of a fraction of an NFT. We will use this token to build our marketplace. Where we can buy or sell the token. A person who will have all token fractions of one NFT will own the complete NFT.

## Create Token.sol

First of all, head back to your `erc404-nftmarketplace-boilerplate` hardhat project. Navigate to the `contracts/Token.sol` file. We will add the token code in this file. If it is not created, create one like this:


![file-struct-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/3%20Build%20the%20MarketPlace/1%20Build%20the%20Token%20-%20I/file-struct-1.png?raw=true)

## Start Coding

Let’s start coding and create our own DN404 token.

### Import dependencies

```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

// Importing DN404 token contract
import "./lib/DN404.sol";
// Importing DN404Mirror contract from external source
import "dn404/src/DN404Mirror.sol";
// Importing Ownable contract from solady library
import {Ownable} from "solady/src/auth/Ownable.sol";
// Importing LibString contract from solady library
import {LibString} from "solady/src/utils/LibString.sol";
// Importing SafeTransferLib contract from solady library
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
// Importing MerkleProofLib contract from solady library
import {MerkleProofLib} from "solady/src/utils/MerkleProofLib.sol";
```

- The code begins with SPDX-License-Identifier specifying the license for the solidity code.
- It declares the solidity version that the code is compatible with.
- It imports various contracts and libraries needed for the functionality of the marketplace contract.

### Initialize the `NFTMintDN404` contract

```
contract NFTMintDN404 is DN404, ERC20Permit, Ownable{
	// Rest of the code goes here
}
```

This line defines a contract named `NFTMintDN404`, inheriting from `DN404`, `ERC20Permit`, and `Ownable` contracts. The rest of the contract code will go inside this contract.

### Declaring variables

```
    string private _name;
    string private _symbol;
    string private _baseURI;
    bytes32 private allowlistRoot;
    uint120 public publicPrice;
    uint120 public allowlistPrice;
    bool public live;
    uint256 public numMinted;
    uint256 public MAX_SUPPLY;
```

- First, we declare private variables named `_name`, `_symbol`, `_baseURI`, and `allowlistRoot`.
- Then, we declare the public variables `publicPrice`, `allowlistPrice`, `live`, `numMinted`, and `MAX_SUPPLY`.

### Custom error definition

```
    error InvalidProof();
    error InvalidPrice();
    error ExceedsMaxMint();
    error TotalSupplyReached();
    error NotLive();
```

- Here, we define multiple custom errors to use in the contract.
- These errors will help print the error message and use fewer gas fees.
- Using string statements is quite costly.
- Custom errors are used the same as events.
- Error is always used with the `revert` statement, where `revert` calls the `error` and passes any argument if there is any.

### Defining the `modifier`

```
    modifier isValidMint(uint256 price, uint256 amount) {
        if (!live) {
            revert NotLive();
        }
        if (price * amount != msg.value) {
            revert InvalidPrice();
        }
        if (numMinted + amount > MAX_SUPPLY) {
            revert TotalSupplyReached();
        }
        _;
    }
```

- Here, we define a `modifier` named `isValidMint` to check if minting is valid.
- The `modifier` allows you to modify an existing function without re-writing the entire function. It helps add functionalities to the function as we have done in our code.
- This modifier ensures that minting can only occur under certain conditions: when the contract is live, when the correct price is paid, and when the total supply limit is not exceeded. If any of these conditions are not met, the transaction is reverted with an appropriate error message.

Let’s understand what is happening inside of the function line-by-line.

```
modifier isValidMint(uint256 price, uint256 amount) {
```

- This `modifier` takes two parameters: `price` and `amount`, representing the price per token and the number of tokens to be minted, respectively.

```
    if (!live) {
        revert NotLive();
    }
```

- Here, we are checking if the contract is live.
- If the contract is not live, it reverts the transaction with the custom error `NotLive`.

```
    if (price * amount != msg.value) {
        revert InvalidPrice();
    }
```

- These lines of code check if the value sent matches the calculated price.
- If the value sent does not match the calculated price, it reverts the transaction with the custom error `InvalidPrice`.

```
    if (numMinted + amount > MAX_SUPPLY) {
        revert TotalSupplyReached();
    }
```

- These lines of code check if minting would exceed the maximum supply.
- If minting exceeds the maximum supply, it reverts the transaction with the custom error `TotalSupplyReached`.

```
    _;
```

- If all the conditions are met, it executes the function or code block that the modifier is applied to.

### Constructor function

```
    constructor(
        string memory name_,
        string memory symbol_,
        uint256 _MAX_SUPPLY,
        uint120 publicPrice_,
        uint96 initialTokenSupply,
        address initialSupplyOwner
    ) ERC20Permit("NFTMintDN404") {
        _initializeOwner(msg.sender);

        _name = name_;
        _symbol = symbol_;
        MAX_SUPPLY = _MAX_SUPPLY;
        publicPrice = publicPrice_;

        address mirror = address(new DN404Mirror(msg.sender));
        _initializeDN404(initialTokenSupply, initialSupplyOwner, mirror);
    }
```

Here, we are defining the constructor function for our `NFTMintDN404` contract. This constructor sets up the initial configuration of the contract, including setting the owner, defining the token's name, symbol, maximum supply, and public price, and initializing the DN404 token contract.

Let’s break down this code and understand it better.

```
constructor(
    string memory name_,
    string memory symbol_,
    uint256 _MAX_SUPPLY,
    uint120 publicPrice_,
    uint96 initialTokenSupply,
    address initialSupplyOwner
) ERC20Permit("NFTMintDN404") {
```

- The constructor function takes several parameters: `name_`, `symbol_`, `_MAX_SUPPLY`, `publicPrice_`, `initialTokenSupply`, and `initialSupplyOwner`.
- It also calls the constructor of the `ERC20Permit` contract with the parameter `"NFTMintDN404"`.

```
    _initializeOwner(msg.sender);
```

- Inside the function, we call the `_initializeOwner` function inherited from the `Ownable` contract, setting the contract deployer as the owner.

```
    _name = name_;
    _symbol = symbol_;
    MAX_SUPPLY = _MAX_SUPPLY;
    publicPrice = publicPrice_;
```

- These lines of code assign values to the contract's name, symbol, maximum supply, and public price variables based on the input parameters provided during deployment.

```
    address mirror = address(new DN404Mirror(msg.sender));
    _initializeDN404(initialTokenSupply, initialSupplyOwner, mirror);
```

- These lines of code create a new instance of the `DN404Mirror` contract, passing the deployer's address as an argument.
- Then, it calls the `_initializeDN404` function inherited from the `DN404` contract, initializing the DN404 token with the initial token supply and the address of the mirror contract.

### Initializing the `mint` function

```
    function mint(uint256 amount) public payable isValidMint(publicPrice, amount) {
        unchecked {
            ++numMinted;
        }
        _mint(msg.sender, amount);
    }
```

Here, we are initializing the `mint` function. This function essentially allows users to mint tokens by sending the appropriate amount of ETH, and it ensures that the minting process is valid by checking against the current `publicPrice` and total supply limits. After validating, it increments the `numMinted` counter and mints the tokens for the user.

Let's break down the `mint` function code and understand it better:

```
function mint(uint256 amount) public payable isValidMint(publicPrice, amount) {
```

- The `mint` function allows users to mint tokens by providing an `amount` of tokens they want to mint.
- The `mint` function is marked as `public`, meaning it can be called externally.
- It also requires users to send ETH along with the function call, as indicated by the `payable` modifier.
- Additionally, it utilizes the `isValidMint` modifier to check if minting is valid based on the provided `publicPrice` and `amount`.

```
    unchecked {
        ++numMinted;
    }
```

- This section uses the `unchecked` keyword, indicating that the arithmetic operations within this block will not be checked for overflows.
- It increments the `numMinted` variable, representing the total number of tokens that have been minted.

```
    _mint(msg.sender, amount);
```

- This line calls the `_mint` function inherited from the `DN404` contract, which mints the specified `amount` of tokens for the caller (`msg.sender`).

### Initializing the `allowlistMint` function

```
    function allowlistMint(uint256 amount, bytes32[] calldata proof)
        public
        payable
        isValidMint(allowlistPrice, amount)
    {
        if (
            !MerkleProofLib.verifyCalldata(
                proof, allowlistRoot, keccak256(abi.encodePacked(msg.sender))
            )
        ) {
            revert InvalidProof();
        }
        unchecked {
            ++numMinted;
        }
        _mint(msg.sender, amount);
    }
```

The `allowlistMint` function allows users on the allowlist to mint tokens by providing proof of eligibility and the desired amount of tokens. It verifies the proof against the allowlist, increments the `numMinted` counter, and mints the tokens for the user if they are eligible. If the proof is invalid, the transaction is reverted with an error message. 

Let's break down the `allowlistMint` function and understand the code line-by-line:

```
function allowlistMint(uint256 amount, bytes32[] calldata proof)
    public
    payable
    isValidMint(allowlistPrice, amount)
{
```

- The `allowlistMint` function allows users on an allowlist to mint tokens by providing an `amount` of tokens they want to mint and a proof of eligibility.
- It's marked as `public`, meaning it can be called externally.
- It also requires users to send ETH along with the function call, as indicated by the `payable` modifier.
- Additionally, it utilizes the `isValidMint` modifier to check if minting is valid based on the provided `allowlistPrice` and `amount`.

```
if (
    !MerkleProofLib.verifyCalldata(
        proof, allowlistRoot, keccak256(abi.encodePacked(msg.sender))
    )
) {
    revert InvalidProof();
}
```

- This block of code checks whether the caller (`msg.sender`) is included in the allowlist by verifying the provided `proof` using the `MerkleProofLib.verifyCalldata` function.
- If the caller is not on the allowlist, it reverts the transaction with the custom error `InvalidProof`.

```
unchecked {
    ++numMinted;
}
```

- This section uses the `unchecked` keyword, indicating that the arithmetic operations within this block will not be checked for overflows.
- It increments the `numMinted` variable, representing the total number of tokens that have been minted.

```
_mint(msg.sender, amount);
```

- This line calls the `_mint` function inherited from the `DN404` contract, which mints the specified `amount` of tokens for the caller (`msg.sender`).

## That’s a wrap

In this lesson, we have completed half of our `NFTMintDN404` contract code. We have added all the main functionalities like defining the constructor function, minting the token, validating the mint process, and allowing the token holders to mint their share of tokens. Next, we will add more functionalities to our `NFTMintDN404` contract. So, stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/3%20Build%20the%20MarketPlace/1%20Build%20the%20Token%20-%20I.md

Build the Token - I

# Build the Token - II

Lastly, you built half of the DN404 token. In this lesson, we will get back to building our DN404 token. Without any delay let's dive in!

## Continue coding

Let’s complete the `NFTMintDN404` contract code.

### Initializing the `setBaseURI` function

```
    function setBaseURI(string calldata baseURI_) public onlyOwner {
        _baseURI = baseURI_;
    }
```

The `setBaseURI` function provides a convenient way for the contract owner to update the base URI for token metadata, which is often used to retrieve additional information about tokens, such as their images or descriptions. By calling this function, the owner can easily customize the metadata URLs without needing to deploy a new contract.

Technically:

- The `calldata` keyword in the input field specifies that the `baseURI_` parameter will be provided as input data to the function.
- `_baseURI` is a private variable that holds the base URI for token metadata.

### Initializing the `setPrices` function

```
    function setPrices(uint120 publicPrice_, uint120 allowlistPrice_) public onlyOwner {
        publicPrice = publicPrice_;
        allowlistPrice = allowlistPrice_;
    }
```

By calling this function, the contract owner can easily adjust the prices for minting tokens without needing to redeploy the contract. This provides flexibility in managing the cost of minting tokens based on market conditions or other factors.

Technically:

- The `setPrices` function allows the contract owner to set the public and allowlist prices for minting tokens. It's marked as `public`, meaning it can be called externally.
- The `onlyOwner` modifier ensures that only the owner of the contract can execute this function.
- Inside of the function, we update the `publicPrice` and `allowlistPrice` variables with the values provided as parameters (`publicPrice_` and `allowlistPrice_`, respectively).
- `publicPrice` represents the price per token for public minting, while `allowlistPrice` represents the price per token for users on the allowlist.

### Initializing the `toggleLive` function

```
    function toggleLive() public onlyOwner {
        live = !live;
    }
```

The `toggleLive` function provides a straightforward way for the contract owner to manage the overall functionality of the contract by enabling or disabling specific features as needed. It offers flexibility and control over the contract's behavior.

Technically:

- The `onlyOwner` modifier ensures that only the owner of the contract can execute this function.
- The `live = !live;` line of code toggles the value of the `live` variable.
- If `live` is currently `true`, it sets it to `false`, and vice versa.
- The `live` variable typically controls whether certain functionalities of the contract are active or not. Toggling it allows the owner to enable or disable specific features of the contract.

### Initializing the `withdraw` function

```
    function withdraw() public onlyOwner {
        SafeTransferLib.safeTransferAllETH(msg.sender);
    }
```

The `withdraw` function provides a secure way for the contract owner to withdraw any accumulated ETH from the contract. By calling this function, the owner can retrieve funds from the contract balance whenever necessary, ensuring control over the contract's financial resources.

Technically, the line `SafeTransferLib.safeTransferAllETH(msg.sender);` works like this:

- This line of code calls the `safeTransferAllETH` function from the `SafeTransferLib` contract.
- The `safeTransferAllETH` function transfers all ETH balances from the contract to the address specified as an argument.
- In this case, `msg.sender` represents the owner of the contract, so all ETH will be transferred to the owner's address.

### Retrieving the basic information

```
    function name() public view override returns (string memory) {
        return _name;
    }

    function symbol() public view override returns (string memory) {
        return _symbol;
    }
```

These functions provide a way for external parties to retrieve basic information about the token, such as its name and symbol. By calling these functions, users or other contracts can obtain essential details about the token without needing access to the contract's internal state variables.

Technically:

- The functions are marked as `public`, meaning they can be called externally.
- The `view` modifier indicates that the functions will not modify the contract's state.
- The `override` keyword indicates that the functions override a function from a parent contract.

### Initializing the `tokenURI` function

```
    function tokenURI(uint256 tokenId) public view override returns (string memory result) {
        if (bytes(_baseURI).length != 0) {
            result = string(abi.encodePacked(_baseURI, LibString.toString(tokenId)));
        }
    }
```

Here, we are initializing the `tokenURI` function. If there's no base URI set, the function returns an empty string. Otherwise, it constructs the full URI for the token metadata by combining the base URI with the token ID. This function is essential for retrieving metadata associated with a specific token, such as its image, description, or attributes.

Let’s understand the code in detail.

- `if (bytes(_baseURI).length != 0) {}`
    - This line checks if the `_baseURI` variable is not empty.
    - If the `_baseURI` is not empty, it means there's a base URI set for token metadata.
- `result = string(abi.encodePacked(_baseURI, LibString.toString(tokenId)));`
    - This line of code constructs the token URI by concatenating the base URI with the string representation of the **`tokenId`**.
    - The **`abi.encodePacked`** function is used to efficiently concatenate the base URI and token ID as a single string.
    - The resulting URI is assigned to the **`result`** variable.

### Initializing the allowlist management functions

```
    function setAllowlist(bytes32 allowlistRoot_) public onlyOwner {
        allowlistRoot = allowlistRoot_;
    }

    function setAllowlistPrice(uint120 allowlistPrice_) public onlyOwner {
        allowlistPrice = allowlistPrice_;
    }
```

These functions provide a straightforward way for the contract owner to manage the allowlist functionality by setting the allowlist root hash and adjusting the price per token for allowlist minting. By calling these functions, the owner can control who is allowed to mint tokens and at what price, ensuring flexibility and customization of the minting process.

### Initializing the utility functions

```
    function nftTotalSupply() public view returns (uint256) {
        return _totalNFTSupply();
    }

    function nftbalanceOf(address owner) public view returns (uint256) {
        return _balanceOfNFT(owner);
    }

    function previewNextTokenId() public view returns (uint256) {
        return _nextTokenId();
    }

    function getURI() public view returns(string memory) {
        return _baseURI;
    }
```

These functions provide useful information and utilities related to the NFTs minted by the contract, such as the total supply, the balance of NFTs owned by a specific address, the ID of the next token to be minted, and the base URI for token metadata. They enable users or other contracts to retrieve essential details about the NFTs managed by the contract.

## Complete code

Here’s the complete code for the `NFTMintDN404` contract that goes in `Token.sol` file.

```
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "./lib/DN404.sol";
import "dn404/src/DN404Mirror.sol";
import {Ownable} from "solady/src/auth/Ownable.sol";
import {LibString} from "solady/src/utils/LibString.sol";
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
import {MerkleProofLib} from "solady/src/utils/MerkleProofLib.sol";



contract NFTMintDN404 is DN404, ERC20Permit, Ownable{
    string private _name;
    string private _symbol;
    string private _baseURI;
    bytes32 private allowlistRoot;
    uint256 public publicPrice;
    uint256 public allowlistPrice;
    bool public live;
    uint256 public numMinted;
    uint256 public MAX_SUPPLY;

    error InvalidProof();
    error InvalidPrice();
    error ExceedsMaxMint();
    error TotalSupplyReached();
    error NotLive();

    modifier isValidMint(uint256 price, uint256 amount) {
        if (!live) {
            revert NotLive();
        }
        if (price * amount != msg.value) {
            revert InvalidPrice();
        }
        if (numMinted + amount > MAX_SUPPLY) {
            revert TotalSupplyReached();
        }
        _;
    }

    constructor(
        string memory name_,
        string memory symbol_,
        string memory uri_,
        uint256 _MAX_SUPPLY,
        uint256 publicPrice_,
        uint256 initialTokenSupply,
        address _owner
    ) ERC20Permit("ERC404Token") {
        _initializeOwner(_owner);

        _name = name_;
        _symbol = symbol_;
        MAX_SUPPLY = _MAX_SUPPLY;
        publicPrice = publicPrice_;
        _baseURI = uri_;
        live = true;

        address mirror = address(new DN404Mirror(msg.sender));
        _initializeDN404(initialTokenSupply, _owner, mirror);
    }

    function mint(uint256 amount) public payable isValidMint(publicPrice, amount) {
        unchecked {
            ++numMinted;
        }
        _mint(msg.sender, amount);
    }

    function allowlistMint(uint256 amount, bytes32[] calldata proof)
        public
        payable
        isValidMint(allowlistPrice, amount)
    {
        if (
            !MerkleProofLib.verifyCalldata(
                proof, allowlistRoot, keccak256(abi.encodePacked(msg.sender))
            )
        ) {
            revert InvalidProof();
        }
        unchecked {
            ++numMinted;
        }
        _mint(msg.sender, amount);
    }

    function setBaseURI(string calldata baseURI_) public onlyOwner {
        _baseURI = baseURI_;
    }

    function setPrices(uint256 publicPrice_, uint256 allowlistPrice_) public onlyOwner {
        publicPrice = publicPrice_;
        allowlistPrice = allowlistPrice_;
    }

    function toggleLive() public onlyOwner {
        if (live)
        {
           live = false;
        } else {
           live = true;
        }
    }

    function withdraw() public onlyOwner {
        SafeTransferLib.safeTransferAllETH(msg.sender);
    }

    function name() public view override returns (string memory) {
        return _name;
    }

    function symbol() public view override returns (string memory) {
        return _symbol;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory result) {
        if (bytes(_baseURI).length != 0) {
            result = string(abi.encodePacked(_baseURI, LibString.toString(tokenId)));
        }
    }

    function setAllowlist(bytes32 allowlistRoot_) public onlyOwner {
        allowlistRoot = allowlistRoot_;
    }

    function setAllowlistPrice(uint256 allowlistPrice_) public onlyOwner {
        allowlistPrice = allowlistPrice_;
    }

    function nftTotalSupply() public view returns (uint256) {
        return _totalNFTSupply();
    }

    function nftbalanceOf(address owner) public view returns (uint256) {
        return _balanceOfNFT(owner);
    }

    function previewNextTokenId() public view returns (uint256) {
        return _nextTokenId(); 
    }

    function getURI() public view returns(string memory) {
        return _baseURI;
    }
}
```

## That’s a wrap

Congratulations! You have implemented the DN404 token from start to end! You are surely a nerd. And we’re so proud of you for this. Next, we will build the marketplace contract. This marketplace contract will help us list our tokens on the marketplace and buy or sell the tokens with ease. So, what are you waiting for? Let’s dive in!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/3%20Build%20the%20MarketPlace/2%20Build%20the%20Token%20-%20II.md

Build the Token - II

# Build the Marketplace - I

Welcome back, folks! Great work on creating the token using the DN404 token standard. In this lesson, we will start writing the code for our marketplace. Why wait? Let’s start!

## Create NFTMarketplace.sol

First of all, head back to your `erc404-nftmarketplace-boilerplate` hardhat project. Navigate to the `contracts/NFTMarketplace.sol` file. We will add the marketplace code in this file. If it is not created, create one like this:

![struct-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/3%20Build%20the%20MarketPlace/3%20Build%20the%20Marketplace%20-%20I/struct-2.png?raw=true)

## Start Coding

Let’s start coding and create our `NFTMarketplace.sol` file.

### SPDX-License-Identifier and Pragma Directive

```
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
```

- `SPDX-License-Identifier`: Specifies the license under which the source code is released. In this case, it's set to "UNLICENSED", indicating that the code has no specific licensing restrictions.
- `pragma solidity ^0.8.20;`: Specifies the Solidity compiler version to be used, indicating that the code is compatible with versions greater than or equal to 0.8.20.

### Import Statements

```
import "./Interface/IDN404.sol";
import "@openzeppelin/contracts/utils/Context.sol";
```

- `import "./Interface/IDN404.sol";`: Imports the interface for contract IDN404.sol located in the Interface directory.
- `import "@openzeppelin/contracts/utils/Context.sol";`: Imports the Context utility from the OpenZeppelin library, which provides contextual information about the current call.

### Error Declarations

```
error PriceNotMet(address nftAddress, uint256 price);
error ItemNotForSale(address nftAddress);
error NotListed(address nftAddress);
error AlreadyListed(address nftAddress);
error NoProceeds();
error NotOwner();
error NotApprovedForMarketplace();
error PriceMustBeAboveZero();
error NotApproved();
```

- Declares custom error messages that can be thrown during execution.

### Contract Definition: NFTMarketplace

```
contract NFTMarketplace is Context {
```

- Defines the main contract `NFTMarketplace`, inheriting from the `Context` contract provided by OpenZeppelin.

### State Variables

```
uint256 private counter;

struct Listing {
    uint256 price;
    address seller;
}
```

- `uint256 private counter;`:
    - Declares a private unsigned integer variable named `counter`.
    - This variable is used to keep track of some count, likely related to the number of listings or transactions in the marketplace.
    - The `private` keyword restricts access to this variable within the contract.
- `struct Listing {`:
    - Declares a new data structure called `Listing`.
    - This struct is used to define the structure of an NFT listing.
    - It contains two fields: `price`, which represents the price of the NFT, and `seller`, which represents the seller's address.
    - `uint256 price;`:
        - Declares a field `price` of type `uint256` within the `Listing` struct.
        - This field represents the price of the NFT being listed.
    - `address seller;`:
        - Declares a field `seller` of type `address` within the `Listing` struct.
        - This field represents the Ethereum address of the seller who listed the NFT.

### Events

```
event LogItemListed(
        address indexed seller,
        address indexed nftAddress,
        uint256 price
    );
```

`event LogItemListed(`

- Defines an event named `LogItemListed`.
- This event is emitted when an NFT is listed for sale in the marketplace.
- It has three parameters:
    - `address indexed seller`: Represents the Ethereum address of the seller who listed the NFT. The `indexed` keyword allows filtering events based on this parameter.
    - `address indexed nftAddress`: Represents the Ethereum address of the NFT being listed. The `indexed` keyword allows filtering events based on this parameter.
    - `uint256 price`: Represents the price at which the NFT is listed.

```
event LogItemCanceled(
        address indexed seller,
        address indexed nftAddress
    );
```

`event LogItemCanceled(`

- Defines an event named `LogItemCanceled`.
- This event is emitted when a listed NFT is canceled by the seller.
- It has two parameters:
    - `address indexed seller`: Represents the Ethereum address of the seller who canceled the listing. The `indexed` keyword allows filtering events based on this parameter.
    - `address indexed nftAddress`: Represents the Ethereum address of the NFT that was canceled. The `indexed` keyword allows filtering events based on this parameter.

```
event LogItemBought(
        address indexed buyer,
        address indexed nftAddress,
        uint256 price,
        uint256 fraction
    );
```

`event LogItemBought(`

- Defines an event named `LogItemBought`.
- This event is emitted when an NFT is bought from the marketplace.
- It has four parameters:
    - `address indexed buyer`: Represents the Ethereum address of the buyer who purchased the NFT. The `indexed` keyword allows filtering events based on this parameter.
    - `address indexed nftAddress`: Represents the Ethereum address of the NFT that was bought. The `indexed` keyword allows filtering events based on this parameter.
    - `uint256 price`: Represents the price at which the NFT was bought.
    - `uint256 fraction`: Represents some fraction or portion of the NFT bought. This parameter might be used if the NFT is divided into fractions or shares.

```
// State Variables
    mapping(address => Listing) private s_listings;
    mapping(address => uint256) private s_proceeds;
```

- `mapping(address => Listing) private s_listings;`:
    - Declares a private mapping named `s_listings`.
    - The key of the mapping is an Ethereum address (`address`), which likely represents the address of an NFT contract.
    - The value associated with each key is a `Listing` struct. This struct contains information about the NFT listing, such as its price and seller.
    - This mapping is used to store the listings of NFTs in the marketplace.
- `mapping(address => uint256) private s_proceeds;`:
    - Declares a private mapping named `s_proceeds`.
    - The key of the mapping is an Ethereum address (`address`), which likely represents the address of a seller.
    - The value associated with each key is a `uint256`, representing the proceeds (amount of Ether) earned by the seller.
    - This mapping is used to keep track of the proceeds earned by each seller from NFT sales in the marketplace.

```
// Function modifiers
    modifier isListed(address nftAddress) {
        Listing memory listing = s_listings[nftAddress];
        require(listing.price > 0, "Not listed");
        _;
    }
```

- `modifier isListed(address nftAddress) {`
    - This is a modifier named `isListed`.
    - It takes one parameter, `nftAddress`, which represents the address of an NFT.
    - Inside the modifier:
        - It creates a memory variable `listing` of type `Listing` and assigns it the value retrieved from the `s_listings` mapping using `nftAddress`.
        - It checks if the `price` in the `listing` is greater than 0, which indicates that the NFT is listed for sale.
        - If the condition is not met, it reverts the transaction with the error message "Not listed".
        - Otherwise, it continues with the execution of the function that uses this modifier.
    - The underscore `_;` indicates where the code of the function using this modifier will be placed.

```
    modifier notListed(address nftAddress) {
        Listing memory listing = s_listings[nftAddress];
        require(listing.price == 0, "Already listed");
        _;
    }
```

- `modifier notListed(address nftAddress) {`
    - This is a modifier named `notListed`.
    - It takes one parameter, `nftAddress`, which represents the address of an NFT.
    - Inside the modifier:
        - It creates a memory variable `listing` of type `Listing` and assigns it the value retrieved from the `s_listings` mapping using `nftAddress`.
        - It checks if the `price` in the `listing` is equal to 0, which indicates that the NFT is not listed for sale.
        - If the condition is not met, it reverts the transaction with the error message "Already listed".
        - Otherwise, it continues with the execution of the function that uses this modifier.
    - The underscore `_;` indicates where the code of the function using this modifier will be placed.

```
    modifier isOwner(address nftAddress, address spender) {
        IDN404 nft = IDN404(nftAddress);
        require(nft.balanceOf(spender) > 0, "Not owner");
        _;
    }
```

- `modifier isOwner(address nftAddress, address spender) {`
    - This is a modifier named `isOwner`.
    - It takes two parameters: `nftAddress`, which represents the address of an NFT, and `spender`, which represents the address of a potential owner.
    - Inside the modifier:
        - It creates a local variable `nft` of type `IDN404` and assigns it the value retrieved from the `IDN404` contract deployed at `nftAddress`.
        - It checks if the `balanceOf` the `spender` address in the `nft` contract is greater than 0, which indicates that the `spender` is the owner of the NFT.
        - If the condition is not met, it reverts the transaction with the error message "Not owner".
        - Otherwise, it continues with the execution of the function that uses this modifier.
    - The underscore `_;` indicates where the code of the function using this modifier will be placed.
    
    ## Wrap up
    
    In summary, in this lesson, we created an Ethereum-based NFT marketplace smart contract, `NFTMarketplace.sol`. It explains the use of key constructs in Solidity, including state variables, events, and function modifiers. The contract enables listing and canceling NFTs for sale and tracks sellers' proceeds.
    
    The code is not done yet, we will be completing it in the upcoming lesson. Stay tuned.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/3%20Build%20the%20MarketPlace/3%20Build%20the%20Marketplace%20-%20I.md

Build the Marketplace - I

# Build the Marketplace - II

Welcome back, folks! Great work on creating and starting to write the code for the marketplace. In this lesson, we will complete the code for our marketplace. Let’s resume!

## Resume Coding

Open `NFTMarketplace.sol` file and resume writing the code in it.

```
function listItemWithPermit(
        address nftAddress,
        uint256 amount, 
        uint256 price,
        uint256 deadline,
        uint8 v, bytes32 r, bytes32 s   
        ) external notListed(nftAddress) {
            
        IDN404 nft = IDN404(nftAddress);

        nft.permit(_msgSender(), address(this), amount, deadline, v, r, s);

        if(nft.allowance(_msgSender(), address(this)) < amount){
            revert NotApproved();
        }

        // Store the listing information
        s_listings[nftAddress] = Listing(price, _msgSender());

        // Emit event
        emit LogItemListed(_msgSender(), nftAddress, price);

        counter++;
    }
```

- This is a function named `listItemWithPermit`.
- It is external, meaning it can be called from outside the contract.
- It takes seven parameters:
    - `nftAddress`: The address of the NFT contract.
    - `amount`: The amount of the NFT to be listed.
    - `price`: The price at which to list the NFT.
    - `deadline`: The deadline for the permit.
    - `v`, `r`, `s`: Components of the permit signature.
- It has a modifier `notListed(nftAddress)`, ensuring that the NFT is not already listed before proceeding.

- `IDN404 nft = IDN404(nftAddress);`: Declares a local variable `nft` of type `IDN404`, representing the NFT contract at `nftAddress`.

- `nft.permit(_msgSender(), address(this), amount, deadline, v, r, s);`
    - Calls the `permit` function of the NFT contract.
    - This function may be a part of an ERC-20 permit mechanism, allowing approval to transfer tokens on behalf of the owner without a separate `approve` transaction.
    - It takes arguments `spender`, `recipient`, `amount`, `deadline`, `v`, `r`, and `s`, likely used for permit signature verification.

- `if(nft.allowance(_msgSender(), address(this)) < amount){revert NotApproved();}`
    - Check if the allowance granted by the `_msgSender()` to the contract (`address(this)`) is less than `amount`.
    - If the condition is not met, revert the transaction with the error `NotApproved()`, indicating that the permit is not approved for the required amount.
- `s_listings[nftAddress] = Listing(price, _msgSender());`:
    - Stores the listing information in the `s_listings` mapping.
    - Associates the `nftAddress` with a new `Listing` struct containing `price` and the address of the `_msgSender()`.

- `emit LogItemListed(_msgSender(), nftAddress, price);`: Emits the `LogItemListed` event with the seller's address (`_msgSender()`), the NFT's address (`nftAddress`), and the listing `price`.

- `counter++;}`: Increments the `counter` variable, likely indicating the number of listings in the marketplace.

```
function cancelListing(address nftAddress)
        external
        isOwner(nftAddress, _msgSender())
        isListed(nftAddress)
    {
        delete s_listings[nftAddress];
        emit LogItemCanceled(_msgSender(), nftAddress);
    }
```

- This is a function named `cancelListing`.
- It is external, meaning it can be called from outside the contract.
- It takes one parameter:
    - `nftAddress`: The address of the NFT contract to cancel the listing for.
- It has two modifiers applied:
    - `isOwner(nftAddress, _msgSender())`: Ensures that the caller (`_msgSender()`) is the owner of the NFT at `nftAddress`.
    - `isListed(nftAddress)`: Ensures that the NFT at `nftAddress` is currently listed for sale.
- `delete s_listings[nftAddress];`:Deletes the listing of the NFT at `nftAddress` from the `s_listings` mapping, effectively canceling the listing.
- `emit LogItemCanceled(_msgSender(), nftAddress);`: Emits the `LogItemCanceled` event with the address of the caller (`_msgSender()`) and the address of the canceled NFT (`nftAddress`).

```
function buyItem(address nftAddress, uint256 fraction)
        external
        payable
        isListed(nftAddress)
    {
        Listing memory listedItem = s_listings[nftAddress];
        require(msg.value >= listedItem.price, "Price not met");

        s_proceeds[listedItem.seller] += msg.value;
        delete s_listings[nftAddress];
        IDN404(nftAddress).transferFrom(listedItem.seller, _msgSender(), fraction);
        emit LogItemBought(_msgSender(), nftAddress, listedItem.price, fraction);
    }
```

- This is a function named `buyItem`.
- It takes two parameters:
    - `nftAddress`: The address of the NFT contract to buy.
    - `fraction`: The fraction or portion of the NFT to buy.
- It is payable, indicating that Ether can be sent along with the function call.
- It has a modifier `isListed(nftAddress)`, ensuring that the NFT at `nftAddress` is listed for sale.
- `Listing memory listedItem = s_listings[nftAddress];`: Declares a local variable `listedItem` of type `Listing` and assigns it the value retrieved from the `s_listings` mapping using `nftAddress`.
- `require(msg.value >= listedItem.price, "Price not met");`: Ensures that the amount of Ether (`msg.value`) sent with the function call is greater than or equal to the price of the listed item.
- If the condition is not met, it reverts the transaction with the error message "Price not met".
- `s_proceeds[listedItem.seller] += msg.value;`: Increments the proceeds of the seller (`listedItem.seller`) by the amount of Ether (`msg.value`) sent by the buyer.
- `delete s_listings[nftAddress];`: Deletes the listing of the NFT at `nftAddress` from the `s_listings` mapping, indicating that it has been sold.
- `IDN404(nftAddress).transferFrom(listedItem.seller, _msgSender(), fraction);`: Transfers the specified `fraction` of the NFT from the seller (`listedItem.seller`) to the buyer (`_msgSender()`) using the `transferFrom` function of the NFT contract at `nftAddress`.
- `emit LogItemBought(_msgSender(), nftAddress, listedItem.price, fraction);`: Emits the `LogItemBought` event with the buyer's address (`_msgSender()`), the address of the purchased NFT (`nftAddress`), the price at which it was bought (`listedItem.price`), and the fraction bought (`fraction`).

```
function withdrawProceeds() external {
        uint256 proceeds = s_proceeds[_msgSender()];
        require(proceeds > 0, "No proceeds");
        s_proceeds[_msgSender()] = 0;

        (bool success, ) = payable(_msgSender()).call{value: proceeds}("");
        require(success, "Transfer failed");
    }
```

- This is a function named `withdrawProceeds`.
- It is external, meaning it can be called from outside the contract.
- It doesn't take any parameters.
- `uint256 proceeds = s_proceeds[_msgSender()];`: Retrieves the proceeds (amount of Ether) available for withdrawal by the caller (`_msgSender()`) from the `s_proceeds` mapping and assigns it to the local variable `proceeds`.

- `require(proceeds > 0, "No proceeds");`
    - Ensures that there are proceeds available for withdrawal.
    - If `proceeds` is not greater than 0, it reverts the transaction with the error message "No proceeds".
- `s_proceeds[_msgSender()] = 0;`: Sets the proceeds of the caller (`_msgSender()`) to 0, effectively marking them as withdrawn.

`(bool success, ) = payable(_msgSender()).call{value: proceeds}("");
require(success, "Transfer failed");`

- Attempts to transfer the `proceeds` amount of Ether to the caller (`_msgSender()`).
- The `payable(_msgSender())` expression converts the caller's address to a payable address, allowing it to receive Ether.
- The `call{value: proceeds}("")` statement invokes the `call` function on the payable address, sending the specified amount of Ether.
- It captures the success status of the transfer in the `success` variable.
- If the transfer is successful, `success` will be `true`.
- If the transfer fails, it reverts the transaction with the error message "Transfer failed".

```
function getListing(address nftAddress)
        external
        view
        returns (Listing memory)
    {
        return s_listings[nftAddress];
    }

    function getProceeds(address seller) external view returns (uint256) {
        return s_proceeds[seller];
    }

    function numListings() external view returns (uint256) {
        return counter;
    }
}
```

- This is a function named `getListing`.
- It is external and view, meaning it can be called from outside the contract and doesn't modify the contract state.
- It takes one parameter:
    - `nftAddress`: The address of the NFT contract.
- It returns a `Listing` struct from the `s_listings` mapping corresponding to the given `nftAddress`.

```
    function getProceeds(address seller) external view returns (uint256) {
        return s_proceeds[seller];
    }
```

- This is a function named `getProceeds`.
- It is external and view, meaning it can be called from outside the contract and doesn't modify the contract state.
- It takes one parameter:
    - `seller`: The address of the seller.
- It returns the proceeds (amount of Ether) available for withdrawal by the given `seller` from the `s_proceeds` mapping.

```
    function numListings() external view returns (uint256) {
        return counter;
    }
}
```

- This is a function named `numListings`.
- It is external and view, meaning it can be called from outside the contract and doesn't modify the contract state.
- It returns the value of the `counter` variable, which likely represents the number of listings in the marketplace.

## Complete code

You can find the complete code [here](https://github.com/Ash20pk/nftmarketplace/blob/main/contracts/NFTMarketplace.sol). 

## Wrap up

In this lesson, we explored the `NFTMarketplace.sol` contract code, understanding the implementation of key functions like listing, buying, and withdrawing proceeds. We also learned about ensuring contract integrity through checks and balances, using events for logging actions and retrieving data from the contract.

In the next lesson, we will deploy our code.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/3%20Build%20the%20MarketPlace/4%20Build%20the%20Marketplace%20-%20II.md

Build the Marketplace - II

Elmer Geonzon

Naufal

Mitisha

Build the MarketPlace

# Write Deploy Scripts

Welcome!! So finally we are done with the code, so can move on to deploying it. But first, we need to write the deploy scripts. So let’s go, Wohoo!

## Deploy script for Token.sol

Navigate to `scripts/deployToken.js` and paste the following code to it: 

```
const { ethers } = require("hardhat");
const fs = require("fs");

async function main() {

  const [deployer] = await ethers.getSigners();
  const name = "Meta";
  const symbol = "META";
  const maxSupply = ethers.parseEther("50");
  const publicPrice = ethers.parseEther("0"); 
  const initialtokenSupply = ethers.parseEther("0"); 
  const signer = deployer.address 

  const argumentsArray = [name, symbol, maxSupply.toString(), publicPrice.toString(), initialtokenSupply.toString(), signer]
  const content = "module.exports = " + JSON.stringify(argumentsArray, null, 2) + ";";
  fs.writeFileSync("./arguments.js", content);

  console.log("arguments.js file generated successfully.");

  console.log("Deploying contracts with the account:", deployer.address);

  const Token = await ethers.getContractFactory("NFTMintDN404");
  const token = await Token.deploy(
    name,
    symbol,
    maxSupply,
    publicPrice,
    initialtokenSupply,
    signer,
  );

  console.log("Fractionalized NFT deployed to:", await token.getAddress());
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });
```

### Code explanation

```
const { ethers } = require("hardhat");
const fs = require("fs");
```

- The script imports the required **`ethers`** package from Hardhat for interacting with Ethereum contracts and the **`fs`** (file system) module for file operations.

```
async function main() {
```

- Defines an asynchronous function named **`main()`** to execute the deployment process.

```
  const [deployer] = await ethers.getSigners();
```

- Retrieves the deployer's Ethereum account (the first account) using **`getSigners()`**.

```
  const name = "Meta";
  const symbol = "META";
  const maxSupply = ethers.parseEther("50");
  const publicPrice = ethers.parseEther("0");
  const initialtokenSupply = ethers.parseEther("0");
  const signer = deployer.address;
```

- Defines various parameters required for deploying the contract, such as **`name`**, **`symbol`**, **`maxSupply`**, **`publicPrice`**, **`initialtokenSupply`**, and **`signer`**.

```
  const argumentsArray = [name, symbol, maxSupply.toString(), publicPrice.toString(), initialtokenSupply.toString(), signer];
```

- Creates an array **`argumentsArray`** containing the deployment arguments.

```
  const content = "module.exports = " + JSON.stringify(argumentsArray, null, 2) + ";";
```

- Converts **`argumentsArray`** into a JSON string with proper formatting and assigns it to the **`content`** variable.

```
  fs.writeFileSync("./arguments.js", content);
```

- Writes the JSON string to a file named **`arguments.js`**.

```
  console.log("arguments.js file generated successfully.");
```

- Logs a success message indicating that the **`arguments.js`** file has been generated.

```
  console.log("Deploying contracts with the account:", deployer.address);
```

- Logs the Ethereum address of the deployer's account.

```
  const Token = await ethers.getContractFactory("NFTMintDN404");
```

- Retrieves the contract factory for the **`NFTMintDN404`** contract.

```
  const token = await Token.deploy(
    name,
    symbol,
    maxSupply,
    publicPrice,
    initialtokenSupply,
    signer,
  );
```

- Deploys the **`NFTMintDN404`** contract with the specified parameters.

```
  console.log("Fractionalized NFT deployed to:", await token.getAddress());}
```

- Logs the Ethereum address where the contract has been deployed.

```
main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });
```

- Invokes the **`main()`** function to start the deployment process.
- If the deployment is successful, it exits the process with code 0; otherwise, it logs any error encountered and exits the process with code 1.

## Deploy script for NFTMarketplace.sol

Navigate to `scripts/deployMarketplace.js` and paste the following code to it: 

```
const { ethers } = require("hardhat"); 

async function main() {

  const [deployer] = await ethers.getSigners();

  console.log("Deploying contracts with the account:", deployer.address);

  const NFTMarketplace = await ethers.getContractFactory("NFTMarketplace");
  const marketplace = await NFTMarketplace.deploy();

  console.log("NFT Marketplace deployed to:", await marketplace.getAddress());
}

main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });
```

### Code explanation

- `const { ethers } = require("hardhat");`: The script imports the required **`ethers`** package from Hardhat for interacting with Ethereum contracts.
- `async function main() {`: Defines an asynchronous function named **`main()`** to execute the deployment process.
- `const [deployer] = await ethers.getSigners();`: Retrieves the deployer's Ethereum account (the first account) using **`getSigners()`**.
- `console.log("Deploying contracts with the account:", deployer.address);`: Logs the Ethereum address of the deployer's account.
- `const NFTMarketplace = await ethers.getContractFactory("NFTMarketplace");`: Retrieves the contract factory for the **`NFTMarketplace`** contract.
- `const marketplace = await NFTMarketplace.deploy();`: Deploys the **`NFTMarketplace`** contract.
- `console.log("NFT Marketplace deployed to:", await marketplace.getAddress());`: Logs the Ethereum address where the contract has been deployed.

```
main()
  .then(() => process.exit(0))
  .catch(error => {
    console.error(error);
    process.exit(1);
  });
```

- Invokes the **`main()`** function to start the deployment process.
- If the deployment is successful, it exits the process with code 0; otherwise, it logs any error encountered and exits the process with code 1.

## Wrap Up

In conclusion, this lesson provided detailed steps on how to write deploy scripts for Ethereum contracts. We learned how to define parameters, retrieve the contract factory, and deploy the contract. We also saw how to handle potential deployment errors. 

In the next lesson, we will run these scripts to deploy the contracts. Stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/4%20Deploy%20the%20MarketPlace/1%20Write%20Deploy%20Scripts.md

Write Deploy Scripts

# Deploy Our Code

Welcome!! So finally we are done with the prerequisites to deploy our code. Let’s quickly dive into running our commands to deploy the contracts.

## Update hardhat.config file

Go to `hardhat.config` file and replace the existing content with the following:

```
require("@nomicfoundation/hardhat-toolbox");
require("@nomicfoundation/hardhat-verify");

/** @type import('hardhat/config').HardhatUserConfig */

const dotenv = require("dotenv");
dotenv.config();

function privateKey() {
  return process.env.PRIVATE_KEY !== undefined ? [process.env.PRIVATE_KEY] : [];
}

module.exports = {
  networks: {
    hardhat: {
      initialDate: "1970-01-01T00:00:00Z",
      accounts: {
        accountsBalance: "1000000000000000000000000000000",
      },
      hardfork: "berlin",
    },
    mumbai: {
      url: "https://rpc.ankr.com/polygon_mumbai",
      accounts: privateKey(),
    }
  },
  solidity: "0.8.20",
  etherscan: {
    apiKey: "S1VXKDQCP4P2VXAK9Q8B46K71TFP9WF692",
  },
};
```

Now we will first compile our files by running the following command:

```
npx hardhat compile
```

The output will be like the following:

![Frame 3560381.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/4%20Deploy%20the%20MarketPlace/Deploy%20Our%20Code/Frame_3560381.jpg?raw=true)

## Deploy the contracts

Now run the following commands:

```
npx hardhat run scripts/deployToken.js --network mumbai
npx hardhat run scripts/deployMarketplace.js --network mumbai
```

Here’s the output:

![Frame 3560381 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/4%20Deploy%20the%20MarketPlace/Deploy%20Our%20Code/Frame_3560381_(1).jpg?raw=true)

## Wrap up

In this lesson, we've walked through the process of deploying our code contracts. This included updating the `hardhat.config` file, compiling our files, and finally deploying the contracts. Hopefully, this has provided you with a practical understanding of how code deployment works. 

In the next lesson, we will work on the frontend so we can interact with our code.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/4%20Deploy%20the%20MarketPlace/2%20Deploy%20Our%20Code.md

Deploy the Code

Kajal Prasad

Deploy the MarketPlace

# Set Up the Frontend

Welcome back, folks! Great work on deploying the contracts. Now, we will use the metadata of our deployed contracts to connect with the frontend. We have already built the frontend for you to save you from the hassle. So let’s set it up in this lesson.

Navigate to the `erc404-nftmarketplace-boilerplate` hardhat project and find the `frontend` folder. This folder contains the frontend for our marketplace project. 

## Connect the frontend

Before running the frontend, we need to connect our hardhat project with the frontend. To do this, after deploying the contracts, navigate to the `erc404-nftmarketplace-boilerplate/artifacts` folder and copy the following files:

1. `/artifacts/contracts/Interface/IDN404.sol/IDN404.json`
2. `/artifacts/contracts/NFTMarketplace.sol/NFTMarketplace.json`
3. `/artifacts/contracts/Token.sol/NFTMintDN404.json`

Now, paste these files into the `frontend/src/contracts` folder.

**Note:** Please notice the path of the files we have given above. Please make sure to copy the right file. Also, without the deployment, you will not find these files in your `erc404-nftmarketplace-boilerplate` hardhat project.

## Set up the environment variables file

Move to the `frontend/src/components/ConnectWallet.js`and update the following environment variables with the addresses you got after deploying the contracts.

```
const marketplaceAddress = "YOUR_MARKETPLACE_ADDRESS";
const nftContractAddress = "YOUR_NFT_CONTRACT_ADDRESS";
```

## Set up the frontend

Before running the frontend, we need to install the dependencies. Move to the `frontend` folder in your terminal and run the following commands.

```
npm install --force
```

## Run the frontend

Run the following command to run the frontend.

```
npm start
```

Your frontend will look like this.

![frontend.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_erc404/5%20Work%20With%20the%20Frontend/Set%20Up%20the%20Frontend/frontend.png?raw=true)

## That’s a wrap

Your frontend is ready to go. Connect your Mumbai network with it using the MetaMask wallet using the same address you used in the deployment lesson. Next, we will interact with it.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/5%20Work%20With%20the%20Frontend/1%20Set%20Up%20the%20Frontend.md

Set Up the Frontend

# Interact With  the Frontend

Great work on setting up the frontend for the marketplace project. Let’s interact with it now.

## Interact with the frontend

Let’s explore our marketplace features one by one.

1. First of all, connect your MetaMask wallet using the “connect wallet” button.
2. Go to the “List NFT” field, enter your NFT contract address, and click on the “List NFT with Permit” button, to list your NFT on the marketplace.
3. If you want to delete the listing, go to the “Cancel Listing” field and click on the “Cancel Listing” button.
4. If you want to buy an NFT share, go to the “Buy NFT” field, enter the NFT details and the amount of share you want to buy, and then click on the “Buy NFT” button.
5. At last, if you want to update the price of your token share, go to the “Update Listing Price” field.

## That’s a wrap

Great work on interacting with the frontend! You are now super hero of the ERC404 token. Next, get an overview of what you have learned in this course.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/5%20Work%20With%20the%20Frontend/2%20Interact%20With%20the%20Frontend.md

Interact With the Frontend

Work With the Frontend

# That’s a Wrap

Congratulations on reaching the end of the course where you learned to build your own nft marketplace dApp using ERC-404. Take a moment and pat on your back for the dedication you have shown to reach here. Before we let you go to build amazing new dApps, let's recap what we have learned in this course.

## Key Learnings:

1. **Development Environment Setup:**
    - Set up the necessary development environment and make sure that you are ready to create decentralized applications.
2. **Smart Contract Development:**
    - Progressed through the step-by-step process of coding a smart contract for the nft marketplace.
3. **Frontend Integration:**
    - Created a frontend for your dApp, showcasing the seamless interaction between smart contracts and user interfaces.
4. **Interaction:**
    - Learned how to interact with your dApp, ensuring that it performs as expected.

## ⚒️ A small yet important request:

This is a 100% open-source project like all the other projects on our platform. You can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects/tree/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai). If you find any issues in the course, please feel free to resolve it. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our repository. We will be very thankful! ❤️
2. We are a completely free platform and we aim to stay the same, so please consider following us on [X](https://twitter.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) as well. 🫶

## 🎊 Congratulations

You have completed the course and are now equipped with the knowledge to create a dApp using ERC-404. Your commitment to learning and building in the blockchain space is commendable. Best of luck in all your future endeavors as you continue to shape the future of decentralized technologies!

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Semi-Fungible%20ERC404%20Tokens'%20Marketplace/6%20Wrap%20Up%20the%20Course/1%20That%E2%80%99s%20a%20Wrap.md

That’s a Wrap

Rupesh

Wrap Up the Course

Setup your wallet to mint your proof of completion NFT

Connect Metamask

Become a part of our vibrant and supportive community!

Join our Discord

Spread the word about what you are building

Follow us on Twitter

Keep us informed of your progress so we can assist you

Submit your first assignment

Reach half course

Complete the course to earn NFT along with XP

Complete Course

Submit your feedback at course completion and help us improve your learning experience

Getting Started

Prerequisites to Building the MarketPlace

Build the MarketPlace

Deploy the MarketPlace

Work With the Frontend

Wrap Up the Course

🎉 Congratulations!!
You've Received a Special NFT

How can we help?

🎉 Congratulations!! You've Received a Special NFT

How can we help?

🎉 Congratulations!!
You've Received a Special NFT