30 Days of Solidity

The best way to learn Solidity is to start coding in Solidity. Do yourself a favor - do better than just watching YouTube tutorials that lead to a lot of watching and very less of building. Enroll in this course to create your own Ethereum smart contract and become a beginner Solidity developer in no time.

<p>Heya folks! I am <a href="https://twitter.com/fatimarizwan" target="_blank" rel="noopener noreferrer">Fama</a> and today I will be helping you write your first ever solidity contract. Not only this, there is much more fun stuff we will be doing during this project. So be excited and please bring your A game here.&nbsp;&nbsp;<br><br>We will cover some&nbsp;&nbsp;<br><br>1. Super cool tools that you need to interact with as a smart contract developer.&nbsp;&nbsp;<br>2. Writing your first ever solidity contract.&nbsp;&nbsp;<br>3. Shipping it to testnet and thennnn, interacting with it too. 🔥🔥&nbsp;&nbsp;<br>4. And understanding transactions on blockchain.</p><h2>Course Overview</h2><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/a8686ce38843432e89dd95577569dad2?sharedAppSource=personal_library"><div class="se-component se-video-container __se__float-" contenteditable="false" style="width: 100%;"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/a8686ce38843432e89dd95577569dad2" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="a8686ce38843432e89dd95577569dad2" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p><p>Please install VScode and node on your machine. Install&nbsp;<a href="https://nodejs.org/en/" target="_blank" rel="noopener noreferrer"><u>node from here</u></a>. Download&nbsp;<a href="https://code.visualstudio.com/" target="_blank" rel="noopener noreferrer"><u>VScode from here.</u></a></p><p>If you complete this course with me today, you will be getting a special NFT, a utility token, which will unlock many more opportunities for you on the Metaschool platform. Here is how the NFT looks like.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh3.googleusercontent.com/XA90aG5m4td1tcxoknDWavsFAFTULftVrzyhnLu8oM5AwEXm93ZChVq5D1h9gqkhMKPKHBkuOzyeA7jMjzogVRngAshjOaLsQo5lsn2U8ZtLt-jUMfZ0gzY5K2B7NdIM8oju6Lhw" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="XA90aG5m4td1tcxoknDWavsFAFTULftVrzyhnLu8oM5AwEXm93ZChVq5D1h9gqkhMKPKHBkuOzyeA7jMjzogVRngAshjOaLsQo5lsn2U8ZtLt-jUMfZ0gzY5K2B7NdIM8oju6Lhw" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="0"></figure></div><p><br></p><p>Now before we move forward, let’s set some house rules first.&nbsp;&nbsp;&nbsp;<br><br>1. Pleaseeeee do your quick assignments properly.&nbsp;&nbsp;&nbsp;<br>2. Join&nbsp;<a href="https://discord.gg/vbVMUwXWgc" target="_blank" rel="noopener noreferrer"><u>our discord server</u></a> and ask all relevant questions there.&nbsp;&nbsp;&nbsp;<br>3. Stay happy and positive!</p><h2 style="margin-left:0px;">🛠 Contributing to this project!</h2><p style="margin-left:0px;">Good news! This is an open source project, you can find the tutorial markdown files <a href="https://github.com/0xmetaschool/Learning-Projects" target="_blank" rel="noopener noreferrer"><u>here</u></a> &amp; the code <a href="https://github.com/0xmetaschool/Hello-World-Smart-Contract" target="_blank" rel="noopener noreferrer"><u>here</u></a>. If you find an issues in the code or tutorial, please feel free to resolve it. We love love love contributions by our community and we give acknowledgement to contributors in our discord and github profile too.</p><p style="margin-left:0px;">Also, don’t forget to star ⭐️ our repository! we will be very thankful! ♥️</p>

﻿# What Are We Building Today?

gm everyone 🌈, I am very excited to bring the very new exciting course for developers just like you, who want to get started with the blockchain ecosystem!

So what are we building today? Today I will be helping you write your first ever solidity contract. Not only this, there is much more fun stuff we will be doing during this project. So be excited and please bring your A game here.

Why Solidity? Because many of the popular blockchains, [Ethereum](https://ethereum.org/en/), [Binance Smart Chain (BSC)](https://bscscan.com/), [Polygon](https://polygon.technology/) etc uses Solidity programming language to write smart contracts. Not only blockchains, but some of the biggest projects in web3 ecosystem, [Uniswap](https://uniswap.org/), [Compound](https://compound.finance/), [Yearn.finance](https://yearn.finance/) etc are in Solidity programming language.

Not only this, the Solidity docs have 580k visits per month and 2.15 pages per visit and almost 270k active Solidity developers per month. Yep! Solidity is the new hot thing in the developers community and Metaschool wants you to get ahead of 90% developers.

## Course overview

We will cover some

1. Super cool tools that you need to interact with as a smart contract developer.
2. Writing your first ever solidity contract.
3. Shipping it to testnet and thennnn, interacting with it too.
4. And understanding transactions on blockchain.

## Who exactly should take this course?

This course is for developers those have the basic programming knowledge. You are a developer who wants to transition or wants to learn about the web3 ecosystem.

## Prerequisites

- Node - Download [Node from here](https://nodejs.org/en/)
- VSCode - Download [VScode from here](https://code.visualstudio.com/)

## Proof of completion

If you complete this course with me today, you will be getting a special NFT, a utility token, which will unlock many more opportunities for you on the Metaschool platform. Here is how the NFT looks like.


![img.gif](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. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/solidity-contract-twitter) and [LinkedIn](https://bit.ly/solidity-contract-linkedin), it would be a great support. 🫣
4. Stay happy and positive!



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

Let's dive deep into the blockchain world!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/1.%20Setting%20up%20the%20environment/1.%20What%20Are%20We%20Building%20Today%3F.md

What Are We Building Today?

<p>Let’s get to setting up the environment first.&nbsp;&nbsp;<br><br>1. We will install and set up our Metamask account.&nbsp;&nbsp;<br>2. We will create an QuickNode app.</p><h4>Creating 🦊 MetaMask wallet&nbsp;</h4><p>Your Metamask wallet is your key to the web3 world. You can interact with the blockchain via a Metamask account. And of course, generally, it is your digital wallet to store, swap and buy cryptocurrencies, tokens, NFTs, and other amazing things in the web3 world.</p><p>Metamask has a mobile application and a Chrome browser extension too. I personally use Metamask on my Chrome browser extension because I do most of the work on my laptop.</p><p>Anyways, let’s go!</p><p>Here are the installation steps:</p><ul><li>Go to MetaMask.io</li><li>Click Download and Install the Chrome Extension.</li><li>Setup your secure password.&nbsp;</li><li>The next step is the most important one.</li><li>Secure your 12-word phrase properly, never share it with anyone. Write it somewhere because if you lose it, you will never have a way to recover your account. So be mindful of that.</li></ul><p>Congrats! your account is created and you must have received a public address. The public address will be in the pattern of:</p><p><em><u>Example: 0x37EA9984481459885141F571907992e7261E837C</u></em></p><p>You can use this public address to buy, trade, and store Ethereum based tokens, cryptos, NFTs and you can even use it to sign in to websites like OpenSea. But are you wondering if it is safe to share this cryptic long address?</p><p>Yes, it is completely safe. You can share this address publicly to accept, buy, trade or store Ethereum based crypto.</p><p>Here are the steps to turn on test networks</p><ol><li>Go to settings</li><li>Open Advanced</li><li>Scroll down to Show Test Networks</li><li>Turn on</li></ol><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh3.googleusercontent.com/J1aA9vZcf8gE3h9ypNI2nQ0-wRypnCCCwNBDHtc7C9qcyzlkbOmlb6IDUxxN1xIwQpfIwSPZrmXy-C5hS65lcFIKg5U0LZaXhGw_y2QxGurmhwZSHcJwK0gk5KCaUpu45pmz8jl2" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="J1aA9vZcf8gE3h9ypNI2nQ0-wRypnCCCwNBDHtc7C9qcyzlkbOmlb6IDUxxN1xIwQpfIwSPZrmXy-C5hS65lcFIKg5U0LZaXhGw_y2QxGurmhwZSHcJwK0gk5KCaUpu45pmz8jl2" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1089,607" style="" data-index="0"></figure></div></figure><p></p><h4>&nbsp;</h4><h4 style="margin-left:0px;">Creating Quick Node ⛓ endpoint</h4><p>Now, we need to set up <a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer">QuickNode</a> with Ethereum testnet nodes, it’s gonna take like 5 mins.</p><p>QuickNode is a platform which helps you access the blockchain environment without going through the hassle of hosting your own node, saving time and resources. This platform lets you access blockchain nodes in a few clicks and you can scale the node performance according to your need thus creating an environment for you to scale your DApp.</p><ul><li>Sign in / Sign up to your<a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer">&nbsp;<strong><u>QuickNode</u></strong></a> account</li><li>Click on create an&nbsp;<a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer"><strong>QuickNode</strong></a> endpoint&nbsp;</li></ul><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh4.googleusercontent.com/nusZ81aRnb8ue5J6qJLN29NG-lQRe-oQcxoeHyplNrA2IpLKg3cBC2tXPE0XXg2JEI1ugLuCX-fSNFYdtJIctMYW9hLWo7jsQxun7aQU6w_0w1Hqb3Md6lMf1Q9bM57zAm0xKmNDzqCNghdNwYHetosBTnWTnmgCLKUarXGyuUs-EHxBKdN33yEVChkU-HQCo0RUCw" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="nusZ81aRnb8ue5J6qJLN29NG-lQRe-oQcxoeHyplNrA2IpLKg3cBC2tXPE0XXg2JEI1ugLuCX-fSNFYdtJIctMYW9hLWo7jsQxun7aQU6w_0w1Hqb3Md6lMf1Q9bM57zAm0xKmNDzqCNghdNwYHetosBTnWTnmgCLKUarXGyuUs-EHxBKdN33yEVChkU-HQCo0RUCw" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1600,900" style="" data-index="1"></figure></div></figure><p></p><ul><li>Now select Ethereum as Network and Goerli as chain and continue</li><li>We don’t need any add-on so click&nbsp;<strong>create endpoint</strong> now</li></ul><p>Now once you create the endpoint you can start setting up our Metamask Wallet with QuickNode. Now let’s move to the next part! Hope this was really easy for you to understand!</p><ul><li>Go to your Metamask wallet and click on the list of networks.</li></ul><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh5.googleusercontent.com/2UexuPf9TiOmgJskf1KjXbksBlQwnTvRS0tU_nzrKg_3wc4hzVAX4SDqifH3y8YyTb2YJIb2NVQEF_ShIkATyplBcz5_zrzxWuKkodQs5h2JJhUWuo4I0kIRECG1evY510WYAJlbc6W9DyTBVb3gCn9KYAi8ECYR_4tMGer7RBrxErQ8-PpNpOYCrNYj6FrRWD5LrQ" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="2UexuPf9TiOmgJskf1KjXbksBlQwnTvRS0tU_nzrKg_3wc4hzVAX4SDqifH3y8YyTb2YJIb2NVQEF_ShIkATyplBcz5_zrzxWuKkodQs5h2JJhUWuo4I0kIRECG1evY510WYAJlbc6W9DyTBVb3gCn9KYAi8ECYR_4tMGer7RBrxErQ8-PpNpOYCrNYj6FrRWD5LrQ" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1432,805" style="" data-index="2"></figure></div></figure><p></p><ul><li>A drop-down list will show up with a list of networks but you need to click on&nbsp;<strong>ADD NETWORK</strong> at the bottom of the list</li><li>Now you will have a form to fill up to add a new network to your metamask account</li><li>Let’s go back to QuickNode Endpoint Dashboard, and copy the HTTPS</li></ul><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh3.googleusercontent.com/rVD2taxs_lfShmW29I27PatQTIx9NZLnBIA3nGnyKye4Q2WQM_tiC8XpeWHCxu5g6irMWCZm6TnD3LqFhrcmwCFIWXAlnqrPoTmBB8XSiaDerKm7PvbNy625amuVm-vutlS8uyb8A1V0RxEdmtDEKDRaq_4X70LClb42guWZVyX-XCrm7htvkcFPwDAPDJMN2acgbg" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="rVD2taxs_lfShmW29I27PatQTIx9NZLnBIA3nGnyKye4Q2WQM_tiC8XpeWHCxu5g6irMWCZm6TnD3LqFhrcmwCFIWXAlnqrPoTmBB8XSiaDerKm7PvbNy625amuVm-vutlS8uyb8A1V0RxEdmtDEKDRaq_4X70LClb42guWZVyX-XCrm7htvkcFPwDAPDJMN2acgbg" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1432,805" style="" data-index="3"></figure></div></figure><p></p><p>Now let’s go back to the Metamask add network form and&nbsp;</p><ul><li>Paste the HTTPS in&nbsp;<strong>New RPC Url</strong> field with 5 as&nbsp;<strong>Chain ID</strong>,&nbsp;</li><li>“ETH” as&nbsp;<strong>Currency Symbol</strong>,&nbsp;</li><li>Ethereum Goerli as&nbsp;<strong>Network Name (Any name as you like)</strong> and&nbsp;</li><li>Finally&nbsp;<a href="https://goerli.etherscan.io/%20"><u>https://goerli.etherscan.io/</u></a> as&nbsp;<strong>Block Explorer URL.</strong>&nbsp;</li><li>Click Save</li></ul><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh3.googleusercontent.com/NxmZPfEJiinySOv3C9APrka5wQATNH-_6XZr2ncTwDNEP6R7liepAkwQ1ApvGZGKVO3pKAndmI7X1SFyO88LrkTmL19pTlIvSZ1xsaXGjZaOo7VTUb7NLorC1Lp3wDjUXkK1oYqLlMsq94NBPDE6Ejv5Z7UvKmG80YMlZ8fQZSMGJ48Xvin122CSeYhDFckwB3wXiA" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="NxmZPfEJiinySOv3C9APrka5wQATNH-_6XZr2ncTwDNEP6R7liepAkwQ1ApvGZGKVO3pKAndmI7X1SFyO88LrkTmL19pTlIvSZ1xsaXGjZaOo7VTUb7NLorC1Lp3wDjUXkK1oYqLlMsq94NBPDE6Ejv5Z7UvKmG80YMlZ8fQZSMGJ48Xvin122CSeYhDFckwB3wXiA" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1432,805" style="" data-index="4"></figure></div></figure><p></p><h4>&nbsp;</h4><h4>Get some fake ETH $$ 🤑</h4><p>Try the following websites and try to get some fake ETHs. 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 ETH.&nbsp;<br><br>All you have to do is to drop your public address on the following links and the ETH will be transferred.</p><p>🔥 <a href="https://goerlifaucet.com/" target="_blank" rel="noopener noreferrer"><u>https://goerlifaucet.com/</u></a></p><h4>Get your private 🦊 MetaMask key</h4><p>Open the Metamask extension to find your private 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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history.</p><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://metaschool.s3-ap-southeast-1.amazonaws.com/images/xR90oDFgwFLgOIN03aIlqFhEpxUhF7R0sS9aBFCR.png" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="xR90oDFgwFLgOIN03aIlqFhEpxUhF7R0sS9aBFCR.png" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="2239,1531" style="" data-index="5"></figure></div></figure><p></p><p>I will tell you how to keep your account and private key safe in the next steps. For now, export the private key and paste it somewhere secure. DON'T COMMIT IT ON GITHUB, DON'T SHARE IT ON DISCORD, DON'T SHARE IT ANYWHERE! IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUND AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.</p><p>BE EXTRAAA VIGILANT!!</p><h2>Video Walkthrough!</h2><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/5d899234b562408fa0d1d69fe3c56ca3?sharedAppSource=personal_library"><div class="se-component se-video-container __se__float-" contenteditable="false" style="width: 100%;"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/5d899234b562408fa0d1d69fe3c56ca3" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="5d899234b562408fa0d1d69fe3c56ca3" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p>

﻿# Setting up

Welcome back! Folks we have a lot to set up before starting our project. But don’t worry, I’ve got you! Just follow the steps and you will be all ready!

Let’s get to setting up the environment:

1. We will install and set up our Metamask account.
2. We will set up the Sepolia testnet environment.
3. We will fetch some fake money.
4. We will set up Hardhat project.
5. We will set up environment variables.

## Creating MetaMask wallet

Your metamask wallet is your key to the web3 world. You can interact with the blockchain via a MetaMask account. And of course, generally, it is your digital wallet to store, swap and buy cryptocurrencies, tokens, NFTs, and other amazing things in the web3 world.

MetaMask has a mobile application and a Chrome browser extension too. I personally use MetaMask on my Chrome browser extension because I do most of the work on my laptop.

Anyways, let’s go!

Here are the installation steps:

- Go to [MetaMask.io](https://metamask.io/)
- Click Download and Install the Chrome Extension.
- Setup your secure password.
- The next step is the most important one.
- Secure your 12-word phrase properly, never share it with anyone. Write it somewhere because if you lose it, you will never have a way to recover your account. So be mindful of that.

Congrats! your account is created and you must have received a public address. The public address will be in the pattern of:

_Example: 0x37EA9984481459885141F571907992e7261E837C_

You can use this public address to buy, trade, and store Ethereum based tokens, cryptos, NFTs and you can even use it to sign in to websites like OpenSea. But are you wondering if it is safe to share this cryptic long address?

Yes, it is completely safe. You can share this address publicly to accept, buy, trade or store Ethereum based crypto.

### Setting up the testnet environment

Complete the following steps:

- Head over to [https://metaschool.so/rpc/sepolia](https://metaschool.so/rpc/sepolia).
- Click on first “Add to Metamask” button. Pointed out the button in following image.

![sepolia-metamask](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/setup-metamask.png?raw=true)

- Click on "Approve" and then "Switch Network" button.

You will be successfully connected to Sepolia network. See in the following gif how I did it where my wallet is already connected. Don't worry about the UI, the “Add to Metamask” button will work the same.

![connect sepoili.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/sepolia-metamask-add.gif?raw=true)

Note: My MetaMask is already connected that’s why you won’t see the "Approve" MetaMask button in this GIF.

## Get some fake Sepolia ETH $$

You can follow the steps given below:

1. Head over to the site: [https://faucets.chain.link/sepolia](https://faucets.chain.link/sepolia).
2. Select both "Drips 250 LINK" and "Drips 0.1 ETH" boxes.
3. Click on the "Continue" button to continue.
![faucet-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/faucet-1.png?raw=true)
4. Paste your wallet address to the given fields, fill in the captha, and click "Continue with GitHub" button.
5. Authenticate your GitHub.
![faucet-2](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/faucet-2-1.png?raw=true)
6. At last, click on the "Get tokens" button.
![faucet-3](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/faucet-2.png?raw=true)

After waiting for some time, you will receive 0.1 Sepolia ETH.

## Set up HardHat project

First make a project directory where you will work and we will install all the dependencies and hardhat there.

Now open your terminal and run the following commands one by one. Just copy and paste one by one.

```
mkdir Hello-World
cd Hello-World
npm install --save-dev hardhat@2.20.0 --force
```

The above commands means that you created a `Hello-World` folder - an empty one. You entered that folder and initialised the project by making a `package.json` file. Then you installed hardhat in the same folder.

If you have followed the instructions properly, and everything went according to the plan, you have HardHat installed. 🎉

Now write the following command on the terminal.

```
npx hardhat init
```

You will see something like this.

![HardHat-output.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/HardHat-output.png?raw=true)

Please follow the guide and create a JavaScript project. Just follow through the questions and answer them yes. For me it was something like below:

![HardHat-output-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/hardhat-output-2.png?raw=true)

You need to install some more dependencies; `hardhat ether`. Hardhat ethers is a plugin that gives us access to `ethers.js` library. `ethers.js` library gives us a way to interact with the blockchain world, we can deploy contracts, we can fetch contracts, we can call their functions, all thanks to this library.

```
npm install --save-dev @nomiclabs/hardhat-ethers ethers --force
```

Lastly, run the following command on safe side to ensure that all required installations are done:

```
npm install @nomiclabs/hardhat-ethers ethers hardhat @nomicfoundation/hardhat-toolbox --force
```

**Side tip : Install [Solidity Extension](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) by Juan Blanco in VScode to help with syntax and coding error issues.**

## Project structure

Let’s open your project in VSCode or Sublime or any other IDE your prefer. The structure will look something like this. I personally and millions of other devs prefer VSCode. You can even install a Solidity extension there.

![Frame 3560339 (1).png](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Setting%20up/Frame_3560339_(1).png?raw=true>)

The contracts directory will have all the contracts for the project and scripts directory will have all the deployments scripts and other stuff related to the project.

## That’s a wrap

Great work on setting up your first HardHat project. 🎊 Next, you will start writing your first Hello World Solidity contract and learn how it is working. So hang in there and keep on learning.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/1.%20Setting%20up%20the%20environment/2.%20Setting%20up.md

Setting Up

<p>We are getting to the meat of this project. Now we will write the code. I hope you have already installed Node to your machine, and have VScode installed.&nbsp;</p><ol><li>Install&nbsp;<a href="https://nodejs.org/en/" target="_blank" rel="noopener noreferrer"><u>node from here</u></a>.</li><li>Download&nbsp;<a href="https://code.visualstudio.com/" target="_blank" rel="noopener noreferrer"><u>VScode from here</u></a></li></ol><p>Open the terminal and run the following commands. &nbsp; &nbsp;&nbsp;</p><pre><code>mkdir Hello-Worldcd Hello-Worldlsnpm init --yesnpm install --save-dev hardhatnpx hardhat</code></pre><p>When you run the last command, you will get an option to create an Empty project with hardhat config. Do pick that and you will see something like this.</p><pre><code>888    888                      888 888               888888    888                      888 888               888888    888                      888 888               8888888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888888    888     "88b 888P"  d88" 888 888 "88b     "88b 888888    888 .d888888 888    888  888 888  888 .d888888 888888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888👷 Welcome to Hardhat v2.11.2 👷‍✔ What do you want to do? - Create an empty hardhat.config.js✨ Config file created ✨</code></pre><p>Now let's open in project in VScode. Open the Hardhat config file.</p><p><strong>✨ <u>Side tip : Install </u></strong><a href="https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity" target="_blank" rel="noopener noreferrer"><strong><u>Solidity Extension</u></strong></a><strong><u> by Juan Blanco in VScode to help with syntax and coding error issues.</u></strong></p><pre><code>/*** @type import('hardhat/config').HardhatUserConfig*/module.exports = {    solidity: "0.8.17",};</code></pre><p>There is not much going on here except for we are mentioning the version of solidity we are using.&nbsp;</p><h4>Creating Directories for Code</h4><p>Now we will create two directories - contracts &amp; scripts.</p><p>The contracts directory will have all the contracts for the project and scripts directory will have all the deployments scripts and other stuff related to the project. By now the structure of your project will look something like this.</p><pre><code>Hello-World&gt; contracts&gt; node_modules&gt; scriptshardhat.config.jspackage-lock.jsonpackage.json</code></pre><p>The contracts directory will have the contract of your Hello World. Create a HelloWorld.sol file in the contracts folder and write the following code.&nbsp;</p><pre><code>// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.4; contract HelloWorld {    //events    //states    //functions     event messagechanged(string oldmsg, string newmsg);     string public message;     constructor(string memory firstmessage) {        message = firstmessage;       }     function update(string memory newmesssage) public {        string memory oldmsg = message;        message = newmesssage;         emit messagechanged(oldmsg, newmesssage);     }}</code></pre><p>We start with mentioning the version of the solidity that we are using and then write the actual contract. A smart contract has states, functions and events.&nbsp;</p><ul><li>The states are usually variables, tokens, NFTs whose state we want to maintain in the contract.</li><li>In order to read, write or change the states, we use functions.&nbsp;&nbsp;</li><li>Events are triggers that are activated based on a transformation in a state, a call to a function etc. So our code right now has a state variable called ‘message’, a function called ‘update’ and and event called ‘messagechanged’.</li></ul><p>This is a basic HelloWorld code that takes a string when the smart contract is first time executed and if we want we can change that value to a new message as well.</p><p>Now that we have written the contract, the next step is to prepare for the deployment.&nbsp;</p><h2>Video Walkthrough</h2><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/60dfe71639bd446c980fbbab3e39df61?sharedAppSource=personal_library"><div class="se-component se-video-container __se__float-" contenteditable="false" style="width: 100%;"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/60dfe71639bd446c980fbbab3e39df61" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="60dfe71639bd446c980fbbab3e39df61" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p>

﻿# Writing The Solidity Contract

Welcome back! So far, you have set up your wallet. Now, we are getting to the meat of this project. In this lesson, we will write code. I hope you have already installed Node to your machine, and have VScode installed.

## Creating the Solidity contract

The contracts directory will have the contract of your Hello World program. Delete the exsiting `contracts/lock.sol` file, create a `HelloWorld.sol` file in the `contracts` folder and write the following code.

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

contract HelloWorld {
    //events
    //states
    //functions

    event messagechanged(string oldmsg, string newmsg);

    string public message;

    constructor(string memory firstmessage) {
        message = firstmessage;
    }

    function update(string memory newmesssage) public {
        string memory oldmsg = message;
        message = newmesssage;

        emit messagechanged(oldmsg, newmesssage);

    }
}

```

We start with mentioning the version of the solidity that we are using and then write the actual contract. A smart contract has states, functions and events.

- The states are usually variables, tokens, NFTs whose state we want to maintain in the contract.
- In order to read, write or change the states, we use functions.
- Events are triggers that are activated based on a transformation in a state, a call to a function etc. So our code right now has a state variable called `message`, a function called `update` and and event called `messagechanged`.

This is a basic `HelloWorld` code that takes a string when the smart contract is first time executed and if we want we can change that value to a new message as well.

Now that we have written the contract, the next step is to prepare for the deployment.

## That's a wrap

And if all that is done, congrats, you have a smart contract ready to go. Yasss!! 🚀 A basic sample JavaScript project is created for you and you can execute your first ever smart contract.

Now, in next lesson, you will do some set ups to run your project smoothly and deploy your contract to your MetaMask contract address.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/2.%20Writing%20the%20actual%20code/Writing%20the%20solidity%20contract.md

Writing the Solidity Contract

<p>First let’s do some basic housekeeping stuff. We know that there are massive scams and security issues happening in the crypto world. You make a mistake and it can cost you a life time.</p><p>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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.</p><pre><code>npm install dotenv --savetouch .gitignore</code></pre><p>Now go ahead and create .env file at the base of your project. Open your .gitignore file and write .env there.</p><p>All the secrets and important keys related to your project will be stored in .env file and we can access this data whenever and wherever. In the gitignore file we simply write .env, it tells git to ignore that file from future commits.</p><p>Open the .env file you have just created. Add your MetaMask Private Key and Alchemy App HTTP URL there. Should be something like this.</p><pre><code>PRIVATE_KEY=YOUR_PRIVATE_KEYAPI_URL_KEY=YOUR_ALCHEMY_APP_URLAPI_KEY=YOUR_API_KEY</code></pre><p>We will update our hardhat config file to setup Goerli Deployment.</p><pre><code>/** * @type import('hardhat/config').HardhatUserConfig */require('dotenv').config(); //all the key value pairs are being made available due to this librequire('@nomiclabs/hardhat-ethers'); const {API_URL_KEY, PRIVATE_KEY} = process.env; //environment variables are being loaded here. module.exports = {  solidity: "0.8.17",  defaultNetwork: 'goerli',  networks: {    hardhat: {},    goerli: {        url: API_URL_KEY,        accounts: [`0x${PRIVATE_KEY}`]    }  }};</code></pre><p>This code is setting up some configurations for a tool called Hardhat, which helps with developing Ethereum applications. It's using a library called dotenv to load some special values called "environment variables" from a file on the computer. These environment variables are named API_URL_KEY and PRIVATE_KEY, and they'll be used in a minute.</p><p>The code is also bringing in another library called hardhat-ethers, which gives some extra helpful functions for working with Ethereum accounts and smart contracts.</p><p>Finally, the code sets up an object with some values that Hardhat can use. There's a version of a programming language called Solidity that's specified, and a default network for Hardhat to use. There's also a configuration for a specific network called goerli, which tells Hardhat what Ethereum node to connect to and what account to use on that network. The account is specified by its private key, which was one of the environment variables that was loaded earlier.</p>

﻿# Getting Ready for Deployment

Great work on creating your first Solidity contract. Now, get ready to do some needful task before deploying your contract.

## 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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history.

1. Open the metamask extension to find your private key.
2. Click on Account.
3. Click on 3 dots on right side and go to “Account Details”.
4. Click on “Show private key”.
5. Enter Metamask password.
6. Copy your private key.

![Frame 3560364 (4).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Getting%20Ready%20for%20Deployment/Frame_3560364_(4).gif?raw=true)

I will tell you how to keep your account and private key safe in the next steps. For now, export the private key and paste it somewhere secure. DON'T COMMIT IT ON GITHUB, DON'T SHARE IT ON DISCORD, DON'T SHARE IT ANYWHERE! IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUND AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.

BE EXTRAAA VIGILANT!!

## Setting up the environment variables

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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.

```
npm install dotenv --save --force
```

Now go ahead and create `.env` file if you haven’t at the base of your project. Open your `.gitignore` file and write `.env` there.

All the secrets and important keys related to your project will be stored in .env file and we can access this data whenever and wherever. In the `gitignore` file we simply write `.env`, it tells git to ignore that file from future commits.

Open the `.env` file you have just created. Replace `YOUR_PRIVATE_KEY` with your MetaMask Private Key.

```
PRIVATE_KEY="YOUR_PRIVATE_KEY"
```

Please do run the following command to make sure each library is installed.

```
npm install --force
```

## Get Alchemy HTTP link

Please follow the following steps to get the HTTP link. We will use this link in our config file to connect our app to the Sepolia network.

1. Login to your Alchemy account.
2. Go to this link: [https://dashboard.alchemy.com/apps](https://dashboard.alchemy.com/apps)
3. Create new app using the "+ Create new app" button.
4. Name your app and write description.
5. After creating the app head over to the "Networks" option from the top left corner.
6. Choose “sepolia” in the Ethereum network as your network.
7. Copy the HTTPS link.

We will use this HTTPS link in the config file. Here’s the image showing the options you need to follow.

![alchemy new app](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets%20for%20Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/Getting%20Ready%20for%20Deployment/faucet-1.1.png?raw=true)

## Updating Hardhat Config file

Open your `hardhat.config.js` file and paste the following code. Don’t forget to update `<YOUR-HTTPS-LINK>` with your Alchemy HTTPS link.

```
require("dotenv").config();
require("@nomiclabs/hardhat-ethers");
const { PRIVATE_KEY } = process.env;
module.exports = {
  solidity: "0.8.24",
  defaultNetwork: "sepolia",
  networks: {
    hardhat: {},
    sepolia: {
      url: "<YOUR-HTTPS-LINK>",
      accounts: [`0x${PRIVATE_KEY}`],
    },
  },
};
```

This will add the Sepolia Network to your HardHat project. It will help you deploy your contract exactly to the Sepolia Network you added in your MetaMask.

## That’s a wrap

In next lesson, we will dive straight into writing the deployment script and deploying the contract to the Sepolia Network.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/3.%20Preparing%20for%20Deployment/1.%20Getting%20Ready%20for%20Deployment.md

Getting Ready for Deployment

<p>Now is the time to write the deployment script. Now, we will create a deploy.js file in the scripts folder and this file will contain all the logic for deployment. Before that we run the following command in the terminal.</p><pre><code>npm install --save-dev @nomiclabs/hardhat-ethers</code></pre><p>Hardhat ethers is a plugin that gives us access to ethers.js library. Ethers.js library gives us a way to interact with the blockchain world, we can deploy contracts, we can fetch contracts, we can call their functions, all thanks to this library.</p><p>Your deploy.js file will look like this.</p><pre><code>const { ethers } = require("hardhat");async function main() {    const HelloWorld = await ethers.getContractFactory('HelloWorld');    const hw = await HelloWorld.deploy("Hello World! Bingo");    console.log('Contract Deployed to:', hw.address);} main().then(() =&gt; process.exit(0)).catch(error =&gt; { console.error(error); process.exit(1);});</code></pre><p>The first line is bringing in a special part of the Hardhat library called "ethers", which gives some helpful functions for working with Ethereum.</p><p>The next part is a function called main, which is going to contain the steps to deploy the smart contract. Inside of the main function, there's a line of code that gets the "contract factory" for a smart contract called "HelloWorld". A contract factory is kind of like a template for a smart contract, and it lets us create new instances of the contract.</p><p>Then, the code creates a new instance of the "HelloWorld" contract and stores it in a variable called hw. The hw variable will be a copy of the "HelloWorld" contract, but it will live on the Ethereum blockchain at a specific address.</p><p>Finally, the code logs the address of the deployed contract to the console, and then the function is set up to finish and exit the program.</p><p>I hope that helps! Let me know if you have any questions.</p><p><strong>Booooooommmmmmmm!!! 🚀🚀🚀🚀 We are ready for deployment. Run the following command.</strong></p><pre><code>npx hardhat run scripts/deploy.js --network goerli</code></pre><p>If all goes well, your contract will be deployed and you will be able to see the address of the contract on the terminal. <strong>🔮🔮Copy that and save in your .env file with variable name as CONTRACT_ADDRESS, we will use it later to interact with the contract.</strong></p><p>Now your .env file should look something like this</p><pre><code>PRIVATE_KEY=YOUR_PRIVATE_KEYAPI_URL_KEY=YOUR_API_URL_KEYAPI_KEY=YOUR_API_KEYCONTRACT_ADDRESS=YOUR_DEPLOYED_CONTRACT_ADDRESS</code></pre><p>Congratulations!! Congratulations!! Congratulations!!</p><p>Your contract is deployed. ⛺️🚀⛺️🚀⛺️</p><p>A cool thing you can do right now is go to <a href="https://goerli.etherscan.io/">goerli.etherscan.io</a> and copy paste your contract and read more about it.</p><p>🔥🔥🔥🔥 Etherscan is <strong>a website to help you view data regarding any pending or confirmed Ethereum blockchain transactions.</strong> Since Ethereum is a public, open blockchain, whenever anyone interacts with it the action is recorded into the transaction history and it is open for anyone to see.</p>

﻿# Writing Deployment Script

Great work on creating your first Solidity contract. In this lesson, you will write the deployment script for your Solidity contract and deploy it on the Sepolia network.

## Deploy script

Now is the time to write the deployment script. Now, we will create a `deploy.js` file in the `scripts` folder and this file will contain all the logic for deployment.

```
async function main() {
  const HelloWorld = await ethers.getContractFactory("HelloWorld");
  console.log("Deploying Contract...")
  const helloWorld = await HelloWorld.deploy("Hello World! Bingo");
  const txHash = helloWorld.deployTransaction.hash;
  const txReceipt = await ethers.provider.waitForTransaction(txHash);
  console.log("Contract deployed to address:",  txReceipt.contractAddress);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

**Booooooommmmmmmm!!! 🚀 We are ready for deployment.**

First, run the following command to compile the smart contract

```
npx hardhat compile
```

You’ll get the following output.

```
Downloading compiler 0.8.9
Compiled 1 Solidity file successfully
```

Now, run the script file using the following command.

```
npx hardhat run scripts/deploy.js --network sepolia
```

When you deploy your contract, you might see a warning related to ‘zodiac sign’ parameter being unused, let’s ignore that for now. We will get to it laterrrrr.

If all goes well, your contract will be deployed and you will be able to see the address of the contract on the terminal. **🔮 Copy that and save in your `.env` file with variable name as `CONTRACT_ADDRESS`, we will use it later to interact with the contract.**

Now your `.env` file should look something like this.

```
PRIVATE_KEY="YOUR_PRIVATE_KEY"
CONTRACT_ADDRESS="YOUR_DEPLOYED_CONTRACT_ADDRESS"

```

Congratulations!! Congratulations!! Congratulations!!

Your contract is deployed. 🚀

## Explore your contract

A cool thing you can do right now is go to [sepolia.etherscan.io](https://sepolia.etherscan.io/) and copy paste your contract address and read more about it.

🔥 Etherscan is **a website to help you view data regarding any pending or confirmed Ethereum blockchain transactions.** Since Ethereum is a public, open blockchain, whenever anyone interacts with it the action is recorded into the transaction history and it is open for anyone to see.

## That’s a wrap

Boom! your `HelloWorld` contract is deployed to the local chain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/3.%20Preparing%20for%20Deployment/2.%20Writing%20Deployment%20Script.md

Writing Deployment Script

<p>In the same scripts folder, create a new file interact.js. And add the following code.</p><pre><code>const { ethers } = require("hardhat"); const API_KEY = process.env.API_KEY; //get from alchemyconst CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS; //deployed contract addressconst PRIVATE_KEY = process.env.PRIVATE_KEY; //metamask const contract = require('../artifacts/contracts/HelloWorld.sol/HelloWorld.json'); // provider - Alchemyconst alchemyProvider = new ethers.providers.AlchemyProvider(network="rinkeby", API_KEY); // signer - youconst signer = new ethers.Wallet(PRIVATE_KEY, alchemyProvider); // contract instanceconst helloWorldContract = new ethers.Contract(CONTRACT_ADDRESS, contract.abi, signer); async function main() {     const message = await helloWorldContract.message();    console.log("the message is "+ message);     const tx = await helloWorldContract.update("Good Bye, World!");    await tx.wait();     const nmessage = await helloWorldContract.message();    console.log("the new message is "+ nmessage);} main().then(() =&gt; process.exit(0)).catch(error =&gt; {  console.error(error);  process.exit(1);});</code></pre><p>This code is using a library called Hardhat to interact with a smart contract that's already been deployed to the Ethereum blockchain.</p><p>The code starts by bringing in the ethers part of the Hardhat library, and then it loads some environment variables that were saved earlier. These variables are the API_KEY, which is used to connect to the Ethereum blockchain, the CONTRACT_ADDRESS, which is the location of the smart contract on the blockchain, and the PRIVATE_KEY, which is the private key for an Ethereum account on MetaMask that's going to be used to sign transactions.</p><p>The code then brings in the contract's ABI (which stands for "Application Binary Interface") and some other information about the contract from a JSON file. The ABI is like a set of instructions for interacting with the contract, and it's needed to create an instance of the contract.</p><p>Next, the code sets up a provider to connect to the Ethereum blockchain using the API_KEY, and then it creates a "signer" object using the PRIVATE_KEY and the provider. The signer will be used to sign transactions that are sent to the contract.</p><p>Then, the code creates an instance of the smart contract using the CONTRACT_ADDRESS, the contract's ABI, and the signer. This gives us a way to call functions on the contract and send transactions to it.</p><p>The main function is then defined. It starts by calling a function on the contract called message to get the current message that's stored in the contract. It then logs this message to the console.</p><p>The code then sends a transaction to the contract to update the message to a new value, using the update function on the contract instance. It waits for this transaction to be processed by the Ethereum network before moving on.</p><p>Finally, the main function calls the message function again to get the updated message, and then it logs the new message to the console.</p><pre><code>npx hardhat run scripts/interact.js --network goerli</code></pre><p>You will see something like this.</p><pre><code>the message is Hello World! Bingothe new message is Good Bye, World!</code></pre><p>Massive congrats! You have made it! You are done. In this course, we learned about:</p><ol><li>Setting up MetaMask<ol style="list-style-type:lower-roman;"><li>Switching Networks</li><li>Getting some Fake eth</li></ol></li><li>Setting up Alchemy App</li><li>Writing your first contract</li><li>Deploying your solidity contract</li><li>Interacting with your contract</li></ol>

﻿# Interacting with the Deployed Contract

Congrats on deploying your first `HelloWorld` contract on Sepolia network. In this lesson, you will write the script to interact with the contract and get the message on your console. Not only this, we will also update the message `HelloWorld` contract message in this lesson.

## Let’s start coding

Inside of the `scripts` folder, create a new file called `interact.js`. And add the following code.

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

const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS; //deployed contract address

async function main() {
  const HelloWorldFactory = await ethers.getContractFactory("HelloWorld");
  HelloWorldContract = await HelloWorldFactory.attach(CONTRACT_ADDRESS);

  //Reading the current message stored
  const message = await HelloWorldContract.message();
  console.log("the message is " + message);

  //Updating the current message
  const tx = await HelloWorldContract.update("Good Bye, World!");
  await tx.wait();

  const nmessage = await HelloWorldContract.message();
  console.log("the new message is " + nmessage);
}

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

## Explanation

Before, moving on to the deployment command, let’s look at what we did in this file.

```
const { ethers } = require("hardhat");
require('dotenv').config();
```

- Here, first we imported the `hardhat` library.
- Then we added the `require` function that helps import the environment variables from the `.env` file.

```
const CONTRACT_ADDRESS = process.env.CONTRACT_ADDRESS; //deployed contract address
```

- This line just set the constant variable `CONTRACT_ADDRESS` to save the contract address from the `.env` file.

```
async function main() {

  const HelloWorldFactory = await ethers.getContractFactory("HelloWorld");
  HelloWorldContract = await HelloWorldFactory.attach(CONTRACT_ADDRESS);
```

- The `main` function is defined as an asynchronous function. It will be the entry point of our script's execution.
- In these lines, we're using the `ethers` library to get a contract factory for `HelloWorld` contract. Think of a contract factory as a blueprint for creating instances of a contract. The `getContractFactory` method is used to retrieve the factory.
- Next, we connect the contract factory to the address stored in the `CONTRACT_ADDRESS` variable. This way, we're pointing to the deployed instance of the `HelloWorld` contract on the blockchain.

```

  const message = await HelloWorldContract.message();
  console.log("the message is " + message);
```

- Here, we're using the attached contract to call the `message` function on the smart contract. This function retrieves a message stored on the blockchain. The result of this function call is stored in the `message` variable.
- We then log the retrieved message to the console.

```

  const tx = await HelloWorldContract.update("Good Bye, World!");
  await tx.wait();
```

- In these lines, we're interacting with the contract to update the stored message. We call the `update` function on the contract, passing in a new message, in this case, `"Good Bye, World!"`.
- The result of this function call is a transaction object (`tx`). We wait for this transaction to be confirmed on the blockchain using the `await tx.wait();` line.

```

  const nmessage = await HelloWorldContract.message();
  console.log("the new message is " + nmessage);
}
```

- After updating the message, we retrieve the new message from the contract using the `message` function again and store it in the `nmessage` variable.
- We then log this new message to the console.

```

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

- Finally, we call the `main` function to execute the code we've written. We chain a `.then()` function to handle successful completion, which exits the script with a status code of 0 (indicating success). If there's an error during execution, we use the `.catch()` function to log the error and exit the script with a status code of 1 (indicating an error).

## Run your code

Run the following command to run the `interact.js` file.

```
npx hardhat run scripts/interact.js --network sepolia
```

You will see the output something like this.

```
the message is Hello World! Bingo
the new message is Good Bye, World!

```

Massive congrats! You have made it! You are done.

## That’s a wrap

In this course, we learned about:

1. Setting up MetaMask
   1. Switching Networks
   2. Getting some Fake eth
2. Setting up the HardHat project
3. Writing your first Solidity smart contract
4. Deploying your Solidity contract
5. Interacting with your contract


## ⚒️ 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/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity). 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://bit.ly/solidity-contract-twitter) and [LinkedIn](https://bit.ly/solidity-contract-linkedin) as well. 🫶



https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Writing%20your%20first%20Hello%20World%20contract%20in%20Solidity/3.%20Preparing%20for%20Deployment/3.%20Interacting%20with%20the%20Deployed%20Contract..md

Interacting with the Deployed Contract

Write Your First Solidity Smart Contract on Ethereum

Although the NFT fever seems to have worn out a little, NFT minting apps are still popular. In fact, in the third quarter of 2021, the trading volume of NFTs  saw a 704% increase compared to the previous quarter. If you are interested in partaking in this billion dollar market, learn the skills and get to work.

<p style="margin-left:0px;">Heya folks! I am <a href="https://twitter.com/fatimarizwan" target="_blank" rel="noopener noreferrer">Fama</a> and today I will be helping you create your first ever Web3 application and ship it too.</p><p style="margin-left:0px;">This is a very cool and exciting project. We will create a react app that takes a users’ date of birth, connects their Metamask wallet and then mints an NFT to their address.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh6.googleusercontent.com/Xyp-fKrsrdWPSomKzLdqJS8-DleqLBqNxHZcF58KTbt-2Qt1MTqjb4veevUVz7WX0Hj4bnXxG3uvQB6y2HkFwXio8dYptZjHy5e5Cj19DZuS8cnuxsZxrTdL9SGRU_JBTWw8dBG5" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="Xyp-fKrsrdWPSomKzLdqJS8-DleqLBqNxHZcF58KTbt-2Qt1MTqjb4veevUVz7WX0Hj4bnXxG3uvQB6y2HkFwXio8dYptZjHy5e5Cj19DZuS8cnuxsZxrTdL9SGRU_JBTWw8dBG5" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="0" origin-size="1600,748"></figure></div><p style="margin-left:0px;"><br></p><p style="margin-left:0px;">This will be a pure example of how an application can interact with a deployed contract. Using this, you can create some engaging apps too. For example:</p><ol><li>A Harry Potter quiz app that tells you which Hogwartz House you belong to?</li><li>A quiz app to see if you are BTS Army or not? (I love BTS!! 🔥)</li><li>The famous 13 personality test</li></ol><p style="margin-left:0px;">For you the sky is the limit. Once you have created this react app, you can come up with unique and fun app ideas, launch them and get users to try your app. This is gonna be so cool and I am already excited to see what dope projects you create.</p><p style="margin-left:0px;">Not only this, there is much more fun stuff we will be doing during this project. So be excited and please bring your A game here.</p><p style="margin-left:0px;">We will:</p><ol><li>Cover some super cool tools that you need to interact with as a smart contract developer.</li><li>Create your first ever Web3 application.</li><li>Mint an NFT</li><li>Interact with a deployed contract.</li><li>Learn how to connect Metamask to a website.</li><li>Ship it to testnet and thennnn, interact with it too. 🔥🔥</li></ol><p style="margin-left:0px;">Please install VScode and node on your machine. Install <a href="https://nodejs.org/en/" target="_blank" rel="noopener noreferrer"><u>node from here</u></a>. Download <a href="https://code.visualstudio.com/" target="_blank" rel="noopener noreferrer"><u>VScode from here.</u></a></p><p style="margin-left:0px;">If you complete this course with me today, you will be getting a special NFT, a utility token, which will unlock many more opportunities for you on the Metaschool platform. Here is how the NFT looks like.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh3.googleusercontent.com/LcZG5dDhsMFkgQ5hXaQosQyBFMVhW5J9rNx30XonmZJway3kX1rmzSet5jEQ4wLynQ-enzHpk-LWdgvS0tP2JrrglCFG1neAiINjOkwT6CNn_Ad-adacqif8Sm4TtaRkBlg0PWRa" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="LcZG5dDhsMFkgQ5hXaQosQyBFMVhW5J9rNx30XonmZJway3kX1rmzSet5jEQ4wLynQ-enzHpk-LWdgvS0tP2JrrglCFG1neAiINjOkwT6CNn_Ad-adacqif8Sm4TtaRkBlg0PWRa" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="1" origin-size="1600,1094"></figure></div><p style="margin-left:0px;"><br></p><p style="margin-left:0px;">Now before we move forward, let’s set some house rules first.&nbsp;</p><ol><li>Pleaseeeee do your quick assignments properly.</li><li>Join <a href="https://discord.gg/vbVMUwXWgc" target="_blank" rel="noopener noreferrer"><u>our discord server</u></a> and ask all relevant questions there.</li><li>Stay happy and positive!</li></ol><h2 style="margin-left:0px;">🛠 Contributing to this project!</h2><p style="margin-left:0px;">Good news! This is an open source project, you can find the tutorial markdown files <a href="https://github.com/0xmetaschool/Learning-Projects" target="_blank" rel="noopener noreferrer"><u>here</u></a> and code <a href="https://github.com/0xmetaschool/Horoscope-NFT-Project" target="_blank" rel="noopener noreferrer"><u>here</u></a>. If you find an issues in the code or tutorial, please feel free to resolve it. We love love love contributions by our community and we give acknowledgement to contributors in our discord and github profile too.</p><p style="margin-left:0px;">Also, don’t forget to star ⭐️ our repository! we will be very thankful! ♥️</p>

# What Are We Building Today

Heya folks! Today I will be helping you create your first ever Web3 application and ship it too.

So what are we building today? We will be building a very cool and exciting project. We will create a react app that takes a users’ date of birth, connects their Metamask wallet and then mint an NFT to their address.

Let’s see at how it will look like by the end of the course.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/assests_for_horoscope/webp%20images%20new/L1%20Image%201.webp)

**Why this project?** This will be a pure example of how an application can interact with a deployed contract. Using this, you can create some engaging apps too. For example:

1. A Harry Potter quiz app that tells you which Hogwartz House you belong to?
2. A quiz app to see if you are BTS Army or not? (I love BTS!!)
3. The famous 13 personality test

For you the sky is the limit. Once you have created this react app, you can come up with unique and fun app ideas, launch them and get users to try your app. This is gonna be so cool and I am already excited to see what dope projects you create.

Not only this, there is much more fun stuff we will be doing during this project. So be excited and please bring your A game here.

## Course overview

We will:

1. Cover some super cool tools that you need to interact with as a smart contract developer.
2. Create your first ever Web3 application.
3. Mint an NFT.
4. Interact with a deployed contract.
5. Learn how to connect Metamask to a website.
6. Ship it to testnet and thennnn, interact with it too.

## Who exactly should take this course?

This course is for beginner web3 developers who wish to learn about building an app in web3. You should have a basic knowledge of blockchain, Solidity Programming language, and a little bit knowledge of front-end as in this course we will focus more on building.

## Prerequisites

- Install [node from here](https://nodejs.org/en/)
- Download [VScode from here.](https://code.visualstudio.com/)
- Metamask extension installed in your browser ([Chrome extension link](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn))

> **Note:** Please refer to [this course](https://metaschool.so/courses/understand-and-setup-metamask-account) to setup your MetaMask if you still hasn’t. Come back to this course after you have set it up.

## Proof of completion

If you complete this course with me, you will be getting XPs and a special NFT which will unlock many more opportunities for you on the Metaschool platform. Here is what the NFT looks like.


![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/assests_for_horoscope/webp%20images%20new/L1%20Image%202.webp)


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. We are a free open-source platform and if you follow us on [X](https://bit.ly/horo-app-twitter) and [LinkedIn](https://bit.ly/horo-app-linkedin), it would be a great support. 🫣
4. Stay happy and positive!






https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/1.%20%F0%9F%8C%88%20Getting%20Started!/1.%20What%20Are%20We%20Building%20Today.md

What Are We Building Today

<p style="margin-left:0px;">Let’s just setup the project and install all the dependencies. Brace yourself and fire up your terminal. We will be running a handful of commands.</p><p style="margin-left:0px;">Blockchain is like a public database and our smart contracts live on that database. This database is publicly available and accessible. Based on our contract’s configuration, anyone or only specific people can play around with our contract. Every time we publish a contract on blockchain, it gets an address - a digital footprint for us to track it. We’ll build everything for the Ethereum Blockchain and also will use Solidity and other libraries for this project.</p><p style="margin-left:0px;">Publishing a contract directly on blockchain for learning purposes will be an expensive deal. Every time we create a new contract, edit the contract or publish it on the blockchain, we incur some cost in the form of ETH, or MATIC. In order to avoid that and test the contracts properly, we will create a test environment which pretty much replicates the production environment, is free to use, and easy to access.</p><p style="margin-left:0px;">For this purpose, we will use <a href="https://hardhat.org/" target="_blank" rel="noopener noreferrer"><u>HardHat</u></a>. Hardhat gives you a local Ethereum network designed for rapid development. It allows you to deploy your contracts, run your tests and debug your code without spending a dime. How cool is that? 😊</p><h3 style="margin-left:0px;">Now install HardHat</h3><p style="margin-left:0px;">First make a project directory where you will work and we will install all the dependencies and hardhat there.</p><p style="margin-left:0px;">Now open your terminal and run the following commands one by one. Just copy and paste one by one.</p><pre><code>mkdir HoroscopeNFTcd HoroscopeNFTnpm init --yesnpm install --save-dev hardhat</code></pre><p style="margin-left:0px;">The above commands means that you created a ‘HoroscopeNFT’ folder - an empty one. You entered that folder and initialised the project by making a package.json file. Then you installed hardhat in the same folder.</p><p style="margin-left:0px;">If you have followed the instructions properly, and everything went according to the plan, you have HardHat installed. 🎉</p><p style="margin-left:0px;">Now write the following command on the terminal.</p><pre><code>npx hardhat</code></pre><p style="margin-left:0px;">You will see something like this 👇</p><pre><code>888    888                      888 888               888888    888                      888 888               888888    888                      888 888               8888888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888888    888     "88b 888P"  d88" 888 888 "88b     "88b 888888    888 .d888888 888    888  888 888  888 .d888888 888888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888👷 Welcome to Hardhat v2.11.2 👷‍? What do you want to do? … ❯ Create a JavaScript project  Create a TypeScript project  Create an empty hardhat.config.js  Quit</code></pre><p style="margin-left:0px;">We will follow the guide and create a JavaScript project. Something like HelloWorld! Just follow through the questions and answer them yes.</p><p style="margin-left:0px;">You will also install some more dependencies; hardhat ether and hardhat waffle in the project. The installation wizard will install those for you. If you haven’t received a prompt for that, run the following command:</p><pre><code>npm install --save-dev @nomicfoundation/hardhat-toolbox</code></pre><p style="margin-left:0px;">We will also install a smart contracts library called OpenZeppelin. It will make it easy for us to develop, run and ship smart contracts.</p><pre><code>npm install @openzeppelin/contracts</code></pre><p style="margin-left:0px;">And if all that is done, congrats, you have a smart contract ready to go. Yasss!! 🚀 A basic sample JavaScript project is created for you and you can execute your first ever smart contract.</p>

# Setting Up the Environment

Welcome back, folks! So we learned the importance of building this Horoscope project. Kudos! In this lesson, we will set up the environment required to build our project.

So get ready to set up the project and install all the dependencies. Brace yourself and fire up your terminal. We will be running a handful of commands.

## Why Hardhat?

Blockchain is like a public database and our smart contracts live on that database. This database is publicly available and accessible. Based on our contract’s configuration, anyone or only specific people can play around with our contract. Every time we publish a contract on the blockchain, it gets an address - a digital footprint for us to track it. We’ll build everything for the Ethereum Blockchain and also will use Solidity and other libraries for this project.

Publishing a contract directly on blockchain for learning purposes will be an expensive deal. Every time we create a new contract, edit the contract, or publish it on the blockchain, we incur some cost in the form of ETH, or MATIC. In order to avoid that and test the contracts properly, we will create a test environment that pretty much replicates the production environment, is free to use, and is easy to access.

For this purpose, we will use  [HardHat](https://hardhat.org/). Hardhat gives you a local Ethereum network designed for rapid development. It allows you to deploy your contracts, run your tests, and debug your code without spending a dime. How cool is that?

### Install HardHat

First, make a project directory where you will work and we will install all the dependencies and hardhat there.

Now open your terminal and run the following commands one by one. Just copy and paste one by one.

```
mkdir HoroscopeNFT
cd HoroscopeNFT
npm install --save-dev hardhat@2.20.0
```

The above commands mean that you created a `HoroscopeNFT` folder - an empty one. You entered that folder and initialized the project by making a `package.json` file. Then you installed hardhat in the same folder.

If you have followed the instructions properly, and everything went according to the plan, you have HardHat installed.

Now write the following command on the terminal.

```
npx hardhat init
```
Create a JavaScript project. Just follow through the questions and answer them yes. For me, it was something like this:

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/assests_for_horoscope/webp%20images%20new/L1%20Image%203.webp)

We will also install a smart contracts library called OpenZeppelin. It will make it easy for us to develop, run, and ship smart contracts.

```
npm install @openzeppelin/contracts
```

## That's a wrap

And if all that is done, congrats, you have a smart contract ready to go. Yasss!! 🚀 A basic sample JavaScript project is created for you and in the next lesson you will execute your first-ever smart contract.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/1.%20%F0%9F%8C%88%20Getting%20Started!/2.%20Setting%20up%20the%20enviroment.md

Setting Up the Environment

<p style="margin-left:0px;">Let’s go! Write the following code in the terminal and hit enter. Make sure you still are in your project directory in your terminal.</p><pre><code>npx hardhat run scripts/deploy.js</code></pre><p style="margin-left:0px;">You will see something like this on your terminal.</p><pre><code>Compiled 1 Solidity file successfullyLock with 1 ETH and unlock timestamp 1695816271 deployed to 0x5FbDB2315678afecb367f032d93F642f64180aa3</code></pre><p style="margin-left:0px;">Congratulations 🎉 you’ve been successful in deploying your first smart contract to your local blockchain environment without having to code a single line. 😅</p><p style="margin-left:0px;">🚨 When you run the above command, your solidity code is converted into bytecode. A new local blockchain is created and your contract is deployed there. But this blockchain is not permanent, every time you build and run your smart contract, a new blockchain is created in your local environment and the contract is deployed.</p><p style="margin-left:0px;">So it is more like a clean slate - start from scratch. We will get back to it later and figure out a way to deploy our contract permanently. For now, just a piece of information for you to digest.</p><p style="margin-left:0px;">Also the above long line of numbers is the address where your contract is deployed. Every contract has its own address. Because of hardhat we were able to create a local blockchain environment just like Ethereum where we can deploy contracts and play around with them free of cost.</p><p style="margin-left:0px;">Let’s open your project in VSCode or Sublime or any other IDE your prefer. The structure will look something like this. I personally and millions of other devs prefer VSCode. You can even install a Solidity extension there.</p><pre><code>HoroscopeNFT-&gt; artifacts-&gt; cache-&gt; contracts    -&gt; Lock.sol-&gt; node_modules-&gt; scripts    -&gt; deploy.js-&gt; tests- hardhat.config.js- package-lock.json- package.json</code></pre><p style="margin-left:0px;">Let us consider an example of a Greeter.sol file which is a contract written in Solidity and it is a very basic one. Let's go through it step by step.</p><pre><code>//SPDX-License-Identifier: Unlicensepragma solidity ^0.8.9; import "hardhat/console.sol"; contract Greeter {    string private greeting;     constructor(string memory _greeting) {        console.log("Deploying a Greeter with greeting:", _greeting);        greeting = _greeting;    }     function greet() public view returns (string memory) {        return greeting;    }     function setGreeting(string memory _greeting) public {        console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);        greeting = _greeting;    }}</code></pre><p>Our greeter file has three parts</p><ol><li>A constructor where we can pass a string type variable called _greeting.</li><li>A function greet() which returns the greeting value. It is a readonly function. It just returns the current value of greeting variable.</li><li>A function setGreeting() where we can set the value of the greeting message. After deploying the contract, we can call this function to change the value of greeting.</li></ol><p style="margin-left:0px;">Are we good so far? If not join our <a href="https://discord.gg/vbVMUwXWgc" target="_blank" rel="noopener noreferrer"><u>Discord community and go to the #questions channel</u></a> and share your questions there.</p><p style="margin-left:0px;">Now let’s open the deploy.js in the scripts folder. Hardhat always runs the compile task when running scripts with its command line interface. If this script is run directly using ‘node’ you may want to call compile manually to make sure everything is compiled.</p><pre><code>// We require the Hardhat Runtime Environment explicitly here. This is optional// but useful for running the script in a standalone fashion through 'node &lt;script&gt;'.// When running the script with 'npx hardhat run &lt;script&gt;' you'll find the Hardhat// Runtime Environment's members available in the global scope.const hre = require("hardhat"); async function main() {  const Greeter = await hre.ethers.getContractFactory("Greeter");  const greeter = await Greeter.deploy("Hello, Hardhat!");   await greeter.deployed();   console.log("Greeter deployed to:", greeter.address);} // We recommend this pattern to be able to use async/await everywhere// and properly handle errors.main()  .then(() =&gt; process.exit(0))  .catch((error) =&gt; {    console.error(error);    process.exit(1);  });</code></pre><p style="margin-left:0px;">In the above code in function main, we get the contract by using its name Greeter. Once we have that, we call the deploy function and pass the greeting ‘Hello, Hardhat!’ to the constructor. This deploys our contract and then we share the contract address on console.</p><p style="margin-left:0px;">How about you deploy the contract with a different greeting message passed on to the constructor and see how it works?</p>

# Running your Hello World Smart Contract

Greetings! So you are all set up and ready to run smart contracts. So let’s dive right into it!

## Project structure

Let’s open your project in VSCode Sublime or any other IDE you prefer. The structure will look something like this. I personally and millions of other devs prefer VSCode. You can even install a Solidity extension there.

![Screen Shot 2023-08-02 at 3.42.01 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/1.%20Getting%20Started/3.%20Getting%20Started/Screen_Shot_2023-08-02_at_3.42.01_PM.webp?raw=true)


## Running your Hello World smart contract

If you look at `contracts/Lock.sol`, you will see an existing solidity file that has a contract in it. Let’s try to run it using the following command in the terminal where you still are in your project directory in your terminal.

```
npx hardhat run scripts/deploy.js
```

You will see something like this on your terminal.

![Screen Shot 2023-08-02 at 3.38.28 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/1.%20Getting%20Started/3.%20Getting%20Started/Screen_Shot_2023-08-02_at_3.38.28_PM.webp?raw=true)

This was deployed successfully because of the file `scripts/deploy.js` that contain the code to deploy your smart contract.

Well congratulations, you’ve been successful in deploying your first smart contract to your local blockchain environment without having to code a single line.

### Explanation

So what’s happened? Let’s try to understand it.

When you run the above command, your solidity code is converted into bytecode. A new local blockchain is created and your contract is deployed there. But this blockchain is not permanent, every time you build and run your smart contract, a new blockchain is created in your local environment and the contract is deployed.

So it is more like a clean slate - start from scratch. We will get back to it later and figure out a way to deploy our contract permanently. For now, just a piece of information for you to digest.

Also, the above long line of numbers is the address where your contract is deployed. Every contract has its own address. Because of hardhat, we were able to create a local blockchain environment just like Ethereum where we can deploy contracts and play around with them free of cost.

![Group 4.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/1.%20Getting%20Started/3.%20Getting%20Started/Group_4.webp?raw=true)

## Let’s write another smart contract

Let’s now write our own code instead of an existing one, so we can understand how we can write code in Solidity.

Just go to the `contracts` folder. Delete `Lock.sol` and create a new file named `Greeter.sol`.

What will this file actually do? We will build a smart contract named "Greeter" with a constructor to initialize a greeting message. 

Our greeter file will have three parts:

1. A constructor where we can pass a string type variable called `_greeting`.
2. A function `greet()` which returns the greeting value. It is a read-only function. It just returns the current value of the greeting variable.
3. A function `setGreeting()` where we can set the value of the greeting message. After deploying the contract, we can call this function to change the value of the greeting.

### Code

Let's start coding.

```
// SPDX-License-Identifier: Unlicense
```

- This is a special comment that specifies the license under which the code is released. In this case, it indicates that the code is released without any license restrictions (Unlicense).

```
pragma solidity ^0.8.20;
```

- This specifies the version of the Solidity programming language required to compile the contract. The caret (`^`) symbol means that the contract is compatible with any version that starts with `0.8.20` but not with version `0.9.0` or above.

**Note:** If the IDE shows a red line below this line, ignore it, as it won’t cause an error when we run the code.

```
import "hardhat/console.sol";
```

- This line imports the `console.sol` library from the Hardhat development environment. The `console` library provides functions for printing debug information to the console during contract execution.

```
contract Greeter {
```

- This begins the declaration of a new Solidity contract named 'Greeter'.

```
string private greeting;
```

- This declares a private string variable named `greeting`. The `private` visibility modifier means that this variable can only be accessed from within the contract itself, not from external contracts or accounts.

```
constructor(string memory _greeting) {
```

- This is the constructor function of the contract, which gets executed only once during contract deployment.
- It takes a string parameter `_greeting`, which is used to set the initial value of the `greeting` variable.

```
console.log("Deploying a Greeter with greeting:", _greeting);
```

- This logs a message to the console during contract deployment, indicating the value of the `_greeting` parameter.

```
greeting = _greeting;
```

- This assigns the value of the `_greeting` parameter to the `greeting` variable, effectively setting the initial greeting message.

```
function greet() public view returns (string memory) {
```

- This declares a public view function named `greet`.
- The `public` modifier means that this function can be called from both inside and outside the contract.
- The `view` modifier means that this function does not modify the contract state and only reads data (it doesn't modify any variables).

```
return greeting;
```

- This statement returns the current value of the `greeting` variable to the caller of the `greet` function.

```
function setGreeting(string memory _greeting) public {
```

- This declares a public function named `setGreeting`.
- The `public` modifier means that this function can be called from both inside and outside the contract.

```
console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
```

- This logs a message to the console, indicating the current value of the `greeting` variable and the new value provided as the `_greeting` parameter.

```
greeting = _greeting;
```

- This assigns the value of the `_greeting` parameter to the `greeting` variable, effectively changing the greeting message.

### Complete code

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

import "hardhat/console.sol";

contract Greeter {
    string private greeting;

    constructor(string memory _greeting) {
        console.log("Deploying a Greeter with greeting:", _greeting);
        greeting = _greeting;
    }

    function greet() public view returns (string memory) {
        return greeting;
    }

    function setGreeting(string memory _greeting) public {
        console.log("Changing greeting from '%s' to '%s'", greeting, _greeting);
        greeting = _greeting;
    }
}
```

- **Call for help:** Are we good so far? If not join our  [Discord community](https://discord.gg/vbVMUwXWgc), go to the [#feedback channel](https://discord.com/channels/924956974628622346/925022798668259359), and share your questions there.

## Deploy the contract

We have deployment scripts in the `scripts` folder. Hardhat always runs the compile task when running scripts with its command line interface. If this script is run directly using `node` you may want to call compile manually to make sure everything is compiled.

Let’s edit the `scripts/deploy.js` file with the following code:

```
// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through 'node <script>'.
// When running the script with 'npx hardhat run <script>' you'll find the Hardhat
// Runtime Environment's members are available in the global scope.
const {ethers} = require("hardhat");
 
async function main() {
  const Greeter = await ethers.getContractFactory("Greeter");
  const greeter = await Greeter.deploy("Hello, Hardhat!");
 
  await greeter.waitForDeployment();
 
  console.log("Greeter deployed to:", await greeter.getAddress());
}
 
// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

### Explanation

The code is a JavaScript script that uses Hardhat to deploy the `Greeter` smart contract to the Ethereum blockchain. It sets up a deployment function named `main`, asynchronously deploys the contract with a greeting message, waits for the deployment to complete, and then logs the contract's address to the console. The recommended error handling ensures that any errors during deployment are properly handled and displayed.

### Command to deploy

Run the following command in the terminal:

```
npx hardhat run scripts/deploy.js
```

You will see something like this on your terminal.

![Screen Shot 2023-08-02 at 4.37.20 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/1.%20Getting%20Started/3.%20Getting%20Started/Screen_Shot_2023-08-02_at_4.37.20_PM.webp?raw=true)

## That’s a wrap

In this lesson, you learned how to get started with writing and deploying smart contracts using Solidity and Hardhat. You learned how to set up your project and run your first contract, as well as how to write your own smart contracts from scratch. You also learned how to deploy your contracts to a local blockchain environment and test them out.

In the next lesson, we will write an NFT contract.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/1.%20%F0%9F%8C%88%20Getting%20Started!/3.%20Running%20your%20Hello%20World%20Smart%20Contract.md

Running your Hello World Smart Contract

<p style="margin-left:0px;">In the contracts folder, create a new file named horoscopeNFT.sol. This is your new contract file. We will write a detailed NFT contract and for that we will use <a href="https://openzeppelin.com/" target="_blank" rel="noopener noreferrer"><u>OpenZeppelin</u></a>. Remember you installed it while setting up your workspace.</p><p style="margin-left:0px;">🚨 OpenZeppelin is a reusable and secure smart contracts library, which means that you can import this library, inherit the contracts in your project and get started without having to worry about security issues and reinventing the wheel. I’d recommend you to check out their official website, read stuff and get to know more.</p><p style="margin-left:0px;">For minting NFTs, we will create a basic contract based on ERC721 - the non-fungible token standard. OpenZeppelin gives us the base ERC721 with all the important functionalities. You can read more about this contract and all functions encapsulated in that contract <a href="https://docs.openzeppelin.com/contracts/4.x/erc721" target="_blank" rel="noopener noreferrer"><u>here</u></a>. And while you are at it, read all the functions and capabilities that come packaged in this magical library <a href="https://docs.openzeppelin.com/contracts/4.x/api/token/erc721" target="_blank" rel="noopener noreferrer"><u>here</u></a>.</p><pre><code>// SPDX-License-Identifier: UNLICENSEDpragma solidity ^0.8.9;import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";import "@openzeppelin/contracts/utils/Counters.sol";import "hardhat/console.sol";contract horoscopeNFT is ERC721URIStorage {    using Counters for Counters.Counter;    Counters.Counter private _tokenIds;    constructor() ERC721("Horoscope", "HSCP") {}    function mintNFT(address recipient, string memory zodiacSign)        public        returns (uint256)    {        _tokenIds.increment();        uint256 newItemId = _tokenIds.current();        _mint(recipient, newItemId);        _setTokenURI(newItemId, "zodiacSign");        return newItemId;    }}</code></pre><p style="margin-left:0px;">Now let me explain the code step by step 😁</p><pre><code>pragma solidity ^0.8.9;</code></pre><p style="margin-left:0px;">This is the version of Solidity we are using in our contract.</p><pre><code>import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";import "@openzeppelin/contracts/utils/Counters.sol";</code></pre><p style="margin-left:0px;">Here we are importing ERC721URIStorage contract, this contract contains ERC721 contracts. The metadata part of the NFT contract needs to be stored somewhere. so we are using an extension of base ERC721 contract which can have URI storage.</p><p style="margin-left:0px;">We are also importing a library called Counters.sol. This is also an OpenZeppelin utility to keep track of NFTs which are to be minted. Let’s say our contract has minted 5 NFTs, and now someone makes a call to the contract to mint another NFT. How does the contract keep track that it’s the 6th NFT? This happens via this utility.</p><pre><code>contract horoscopeNFT is ERC721URIStorage {    using Counters for Counters.Counter;    Counters.Counter private _tokenIds;     constructor() ERC721("Horoscope", "HSCP") {}</code></pre><p style="margin-left:0px;">Here we are creating a contract called horoscopeNFT and inheriting ERC721URIStorage. As I mentioned earlier, Counters is a utility, a library, so we call it differently as you can see from the code. Then we are creating a private _tokenIds counter with default value as 0. By making it private, no one outside the contract can call it.</p><p style="margin-left:0px;">The constructor is the first function which is called when we deploy our contract and all we are doing is specifying ERC721 and giving it a name Horoscope and symbol HSCP. This name will be reflected in Opensea, Rarible and Etherscan - both the names and symbol. So Horoscope is the name of our NFT collection and HSCP is the symbol. This constructor function ERC721 is coming from ERC721URIStorage. It is not visible here because it is inside this file.</p><pre><code>function mintNFT(address recipient, string memory zodiacSign)    public    returns (uint256){    _tokenIds.increment();    uint256 newItemId = _tokenIds.current();    _mint(recipient, newItemId);    _setTokenURI(newItemId, "zodiacSign");    return newItemId;}</code></pre><p style="margin-left:0px;">This is the public function where we will pass the address of the person who is minting the NFT and their zodiac sign. Once the contract is deployed, anyone can call this function.</p><p style="margin-left:0px;">Unlike the constructor, this function is not called when the contract is deployed but is called on demand. I have kept it very simple. The function first increments the token number, then mints the NFT to recipient address and passes the current NFT number.</p><p style="margin-left:0px;">In the setTokenURI, it saves the NFT number along with the NFT data. In the NFT data, I am merely passing a string ‘zodiacSign’ but this is where we will be passing on all the metadata related to our NFT.</p><p style="margin-left:0px;">Now let’s take a look at our script file deploy.js in the scripts folder and see how do we deploy this project and call this function.</p><pre><code>const hre = require("hardhat"); async function main() {      // We get the contract to deploy      const horoscopeNFT = await hre.ethers.getContractFactory("horoscopeNFT");    const hscp = await horoscopeNFT.deploy();       await hscp.deployed();        console.log("horoscopeNFT deployed to:", hscp.address);    }  // We recommend this pattern to be able to use async/await// everywhere and properly handle errors.main()    .then(() =&gt; process.exit(0))      .catch((error) =&gt; {        console.error(error);    process.exit(1);  });</code></pre><p style="margin-left:0px;">Now let’s run our contract and see how it goes.</p><pre><code>npx hardhat compilenpx hardhat run scripts/deploy.js</code></pre><p style="margin-left:0px;">When you deploy your contract, you might see a warning related to ‘zodiac sign’ parameter being unused, let’s ignore that for now. We will get to it laterrrrr.</p><pre><code>horoscopeNFT deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3</code></pre><p style="margin-left:0px;">Boom! your horoscopeNFT contract is deployed to the local chain. Now we will move to the testnet and add real image to our NFT too.</p>

# Writing and Deploying Basic NFT Contract

Welcome back! So by now, you have built up enough knowledge to get started with a core part of the project. We will be writing and understanding the NFT contract in this lesson.

## Writing the NFT contract

So first of all, in the `contracts` folder, create a new file named `horoscopeNFT.sol`. 

This is your new contract file. We will write a detailed NFT contract and for that, we will use  [OpenZeppelin](https://openzeppelin.com/). Remember you installed it while setting up your workspace.

- **OpenZeppelin** is a reusable and secure smart contracts library, which means that you can import this library, inherit the contracts in your project, and get started without having to worry about security issues and reinventing the wheel. I’d recommend you to check out their official website, read stuff, and get to know more.

For minting NFTs, we will create a basic contract based on ERC721 - the non-fungible token standard. OpenZeppelin gives us the base ERC721 with all the important functionalities. You can read more about this contract and all functions encapsulated in that contract [here](https://docs.openzeppelin.com/contracts/4.x/erc721). And while you are at it, read all the functions and capabilities that come packaged in this magical library [here](https://docs.openzeppelin.com/contracts/4.x/api/token/erc721).

## Complete code

The complete code for NFT is as follows:

```
// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "hardhat/console.sol";

contract horoscopeNFT is ERC721URIStorage {
    uint256 private _tokenIds;

    constructor() ERC721("Horoscope", "HSCP") {}

    function mintNFT(address recipient, string memory zodiacSign)
        public
        returns (uint256)
    {
        uint256 newItemId = _tokenIds;
        _safeMint(recipient, newItemId);
        _setTokenURI(newItemId, zodiacSign);
        _tokenIds += 1;
        return newItemId;
    }
}
```

## Explanation

Now let me explain the code step by step 😁

```
pragma solidity ^0.8.20;
```

- This is the version of Solidity we are using in our contract. Ignore any red line you might see below this line.

```
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "hardhat/console.sol";
```

- Here we are importing `ERC721URIStorage` contract, this contract contains ERC721 contracts. The metadata part of the NFT contract needs to be stored somewhere, so we are using an extension of the base ERC721 contract which can have URI storage.

```
contract horoscopeNFT is ERC721URIStorage {
    uint256 private _tokenIds;

    constructor() ERC721("Horoscope", "HSCP") {}

```

- Here we are creating a contract called `horoscopeNFT` and inheriting `ERC721URIStorage`.
- Then we create a private `_tokenIds` counter with a default value of `0`. By making it private, no one outside the contract can call it.
- The constructor is the first function that is called when we deploy our contract and all we are doing is specifying ERC721 and giving it the name Horoscope and symbol HSCP. This name will be reflected in Opensea, Rarible, and Etherscan - both the names and symbols. So Horoscope is the name of our NFT collection and HSCP is the symbol. This constructor function `ERC721` is coming from `ERC721URIStorage`. It is not visible here because it is inside this file.

```
function mintNFT(address recipient, string memory zodiacSign)
        public
        returns (uint256)
    {
        uint256 newItemId = _tokenIds;
        _safeMint(recipient, newItemId);
        _setTokenURI(newItemId, zodiacSign);
        _tokenIds += 1;
        return newItemId;
    }
```

- This is the public function where we will pass the address of the person who is minting the NFT and their zodiac sign. Once the contract is deployed, anyone can call this function.
- Unlike the constructor, this function is not called when the contract is deployed but is called on demand. I have kept it very simple. The function first increments the token number, then mints the NFT to recipient address and passes the current NFT number.
- In the `setTokenURI`, it saves the NFT number along with the NFT data. In the NFT data, I am merely passing a string `zodiacSign` but this is where we will be passing on all the metadata related to our NFT.

## Deploying the NFT contract locally

Now let’s update our script file `deploy.js` in the `scripts` folder with the following code: 

```
const hre = require("hardhat");

async function main() {
  console.log("Deploying Contract...");
  const horoscope = await hre.ethers.deployContract(
    "contracts/horoscopeNFT.sol:horoscopeNFT"
  );
  console.log("Contract deployed to address:", horoscope.target);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

Now let’s run our contract and see how it goes.

```
npx hardhat compile
npx hardhat run scripts/deploy.js
```

- When you deploy your contract, you might see a warning related to the ‘zodiac sign’ parameter being unused, let’s ignore that for now. We will get to it laterrrrr.
    
    

This is how the output will look like:

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/1%20Writing%20Basic%20NFT%20Contract/Untitled.webp?raw=true)

Remember, here we deployed the contract locally and not on any network. We will deploy the contract on testnet in upcoming lessons.

## That’s a wrap

Boom! Your `horoscopeNFT` contract is deployed to the local chain. Now we will move to the testnet and add real images to our NFT too.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/2.%20%F0%9F%92%BB%20Writing%20the%20NFT%20contract/1.%20%20Writing%20and%20Deploying%20Basic%20Contract.md

Writing and Deploying Basic Contract

<p style="margin-left:0px;">Every NFT has some data linked to it in the form of JSON format that describes the NFT. We call it metadata. This metadata has a special JSON format and the format needs to be followed if we want our NFT to appear properly on platforms like OpenSea, Rarible, etc.</p><p style="margin-left:0px;">In the previous lesson, I shared how we wrote ‘zodiacSign’ instead of sharing the Uniform Resource Identifier, I mean, the data about the NFT. 😅</p><p style="margin-left:0px;">Let’s look back at it 👀</p><pre><code>_setTokenURI(newItemId, "zodiacSign");</code></pre><p style="margin-left:0px;">Now we will use the standard format required by NFT platforms to describe the data related to the NFT. The following is the JSON structure, we are mentioning name of Image, Description, and attributes related to Image. With Image, you can give a link to externally hosted image, or just create an SVG structure.</p><pre><code>{    "name":"Virgo",    "description":"Perfectionist. Great Educators. Overthinkers.",    "image":"your-hosted-img-url.jpg or svg",    "attributes":    [        { "trait_type":"Zodiac","value":"Virgo"        },        { "trait_type":"Month","value":"August"        }    ]}</code></pre><p style="margin-left:0px;">For this project, I am creating a basic black box of SVG, that has the zodiac name mentioned in the center. I’d urge you to be creative and come up with something exciting.</p><pre><code>&lt;svg width="350" height="350" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="xMinYMin meet"&gt; &lt;g&gt;  &lt;title&gt;Layer 1&lt;/title&gt;  &lt;rect id="svg_1" fill="black" height="100%" width="100%"/&gt;  &lt;text id="svg_2" font-size="24px" font-family="serif" fill="white" text-anchor="middle" dominant-baseline="middle" class="base" y="50%" x="50%"&gt;Virgo&lt;/text&gt; &lt;/g&gt;&lt;/svg&gt;</code></pre><p style="margin-left:0px;">This is my svg structure, I will dynamically replace Virgo with the calculated Zodiac sign in future. For now lets finalize our metadata and then run this smart contract.</p><p style="margin-left:0px;">I will go back to my horoscopeNFT contract file and first I will make my svg code dynamic so that the zodiac sign name can be added to the image in run time. I will declare string type baseSvg and add the first part of my svg. This line will go right after the Counters declaration.</p><pre><code>string baseSvg = "&lt;svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinYMin meet' viewBox='0 0 350 350'&gt;&lt;style&gt;.base { fill: white; font-family: serif; font-size: 24px; }&lt;/style&gt;&lt;rect width='100%' height='100%' fill='black' /&gt;&lt;text x='50%' y='50%' class='base' dominant-baseline='middle' text-anchor='middle'&gt;";</code></pre><p style="margin-left:0px;">Next, I will open the mintNFT function and do the following.</p><pre><code>function mintNFT(address recipient, string memory zodiacSign)   public   returns (uint256){   _tokenIds.increment();    string memory finalSvg = string(       abi.encodePacked(baseSvg, zodiacSign, "&lt;/text&gt;&lt;/svg&gt;")   );    // Get all the JSON metadata in place and base64 encode it.   string memory json = Base64.encode(       bytes(           string(               abi.encodePacked(                   '{"name": "',zodiacSign,                   // We set the title of our NFT as the generated word.                   '", "description": "On-chain Zodiac Sign NFTs", "attributes": [{"trait_type": "Zodiac Sign", "value": "',                   zodiacSign,                   '"}], "image": "data:image/svg+xml;base64,',                   // We add data:image/svg+xml;base64 and then append our base64 encode our svg.                   Base64.encode(bytes(finalSvg)),                   '"}'               )           )       )   );    // Just like before, we prepend data:application/json;base64, to our data.   string memory finalTokenUri = string(       abi.encodePacked("data:application/json;base64,", json)   );    uint256 newItemId = _tokenIds.current();   _mint(recipient, newItemId);   _setTokenURI(newItemId, finalTokenUri);    return newItemId;}</code></pre><p style="margin-left:0px;">Let me explain the code step by step.</p><pre><code> string memory finalSvg = string(        abi.encodePacked(baseSvg, zodiacSign, "&lt;/text&gt;&lt;/svg&gt;")    );</code></pre><p style="margin-left:0px;">Here we are just concatenating the baseSvg, the zodiacSign and end tags. Then we wrap it in string just to make sure that our final outcome is string type.</p><pre><code>// Get all the JSON metadata in place and base64 encode it.    string memory json = Base64.encode(        bytes(            string(                abi.encodePacked(                    '{"name": "',zodiacSign,                    // We set the title of our NFT as the generated word.                    '", "description": "On-chain Zodiac Sign NFTs", "attributes": [{"trait_type": "Zodiac Sign", "value": "',                    zodiacSign,                    '"}], "image": "data:image/svg+xml;base64,',                    // We add data:image/svg+xml;base64 and then append our base64 encode our svg.                    Base64.encode(bytes(finalSvg)),                    '"}'                )            )        )    );</code></pre><p style="margin-left:0px;">We create our json structure and encode it in base64. Similarly, we populate finalTokenURI with json structure, encode it in base64 and declare the format to be json.</p><pre><code>// Just like before, we prepend data:application/json;base64, to our data.    string memory finalTokenUri = string(        abi.encodePacked("data:application/json;base64,", json)    );</code></pre><p style="margin-left:0px;">Awesome! Phew!! The hardest part is over. This is how the final contract looks like.</p><pre><code>//SPDX-License-Identifier: Unlicensepragma solidity ^0.8.9;import "@openzeppelin/contracts/token/ERC721/ERC721.sol";import "@openzeppelin/contracts/utils/Counters.sol";import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";import "./Base64.sol";contract horoscopeNFT is ERC721URIStorage {    using Counters for Counters.Counter;    Counters.Counter private _tokenIds;string baseSvg =    "&lt;svg xmlns='http://www.w3.org/2000/svg' preserveAspectRatio='xMinYMin meet' viewBox='0 0 350 350'&gt;&lt;style&gt;.base { fill: white; font-family: serif; font-size: 24px; }&lt;/style&gt;&lt;rect width='100%' height='100%' fill='black' /&gt;&lt;text x='50%' y='50%' class='base' dominant-baseline='middle' text-anchor='middle'&gt;";constructor() ERC721("Horoscope NFT", "HNFT") {}function mintNFT(address recipient, string memory zodiacSign)    public    returns (uint256){    _tokenIds.increment();    string memory finalSvg = string(        abi.encodePacked(baseSvg, zodiacSign, "&lt;/text&gt;&lt;/svg&gt;")    );    // Get all the JSON metadata in place and base64 encode it.    string memory json = Base64.encode(        bytes(            string(                abi.encodePacked(                    '{"name": "',zodiacSign,                    // We set the title of our NFT as the generated word.                    '", "description": "On-chain Zodiac Sign NFTs", "attributes": [{"trait_type": "Zodiac Sign", "value": "',                    zodiacSign,                    '"}], "image": "data:image/svg+xml;base64,',                    // We add data:image/svg+xml;base64 and then append our base64 encode our svg.                    Base64.encode(bytes(finalSvg)),                    '"}'                )            )        )    );    // Just like before, we prepend data:application/json;base64, to our data.    string memory finalTokenUri = string(        abi.encodePacked("data:application/json;base64,", json)    );    uint256 newItemId = _tokenIds.current();    _mint(recipient, newItemId);    _setTokenURI(newItemId, finalTokenUri);    return newItemId;    }}</code></pre><p style="margin-left:0px;">Since we are encoding our json and svg in Base64, we will need to import that file too. Here is the <a href="https://github.com/Metaschoolso/Learning-Projects/blob/main/Base64.sol" target="_blank" rel="noopener noreferrer"><u>link to download</u></a> that file and add to your contracts folder.</p><p style="margin-left:0px;">Our function mintNFT is dynamic now, it takes the address and zodiac sign and then mints an NFT to the account.</p><p style="margin-left:0px;">Now we will prepare for deployment.</p>

# Adding Image and Info to NFT

Welcome back! So by now you have written your NFT contract. In this lesson, we will add image and required information to NFT. So why wait, let’s continue!

## NFT metadata

Every NFT has some data linked to it in the form of JSON format that describes the NFT. We call it metadata. This metadata has a special JSON format and the format needs to be followed if we want our NFT to appear properly on platforms like OpenSea, Rarible, etc.

In the previous lesson, I shared how we wrote `zodiacSign` instead of sharing the Uniform Resource Identifier, I mean, the data about the NFT. 

Let’s look back at it.

```
_setTokenURI(newItemId, zodiacSign);
```

### Understanding metadata structure

Now we will use the standard format required by NFT platforms to describe the data related to the NFT. The following is the JSON structure, we are mentioning the name of the Image, Description, and attributes related to the Image. With Image, you can give a link to the externally hosted image, or just create an SVG structure.

```
{
    "name":"Virgo",
    "description":"Perfectionist. Great Educators. Overthinkers.",
    "image":"your-hosted-img-url.jpg or svg",
    "attributes":
    [
        { "trait_type":"Zodiac","value":"Virgo"
        },
        { "trait_type":"Month","value":"August"
        }
    ]
}
```

For this project, I am creating a basic black box of SVG, that has the zodiac name mentioned in the center. I’d urge you to be creative and come up with something exciting.

```
<svg width="350" height="350" xmlns="<http://www.w3.org/2000/svg>" preserveAspectRatio="xMinYMin meet">
 <g>
  <title>Layer 1</title>
  <rect id="svg_1" fill="black" height="100%" width="100%"/>
  <text id="svg_2" font-size="24px" font-family="serif" fill="white" text-anchor="middle" dominant-baseline="middle" class="base" y="50%" x="50%">Virgo</text>
 </g>
</svg>
```

This is my SVG structure, I will dynamically replace Virgo with the calculated Zodiac sign in the future. 

Now lets finalize our metadata and then run this smart contract.

## Update `horoscopeNFT.sol`

First of all, I will go back to my `horoscopeNFT` contract file and add the following imports to the `horoscopeNFT.sol` file.

```
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Base64.sol";
```

Then, I will make my SVG code dynamic so that the zodiac sign name can be added to the image in run time. I will declare string type `baseSvg` and add the first part of my SVG. **The following line will go right after the counter declaration: `uint256 private _tokenIds;`**

```
string baseSvg = "<svg xmlns='<http://www.w3.org/2000/svg>' preserveAspectRatio='xMinYMin meet' viewBox='0 0 350 350'><style>.base { fill: white; font-family: serif; font-size: 24px; }</style><rect width='100%' height='100%' fill='black' /><text x='50%' y='50%' class='base' dominant-baseline='middle' text-anchor='middle'>";

```

Next, I will open the `mintNFT` function and replace the existing code with the following code.

```
function mintNFT(address recipient, string memory zodiacSign)
   public
   returns (uint256)
{
   _tokenIds.increment();

   string memory finalSvg = string(
       abi.encodePacked(baseSvg, zodiacSign, "</text></svg>")
   );

   // Get all the JSON metadata in place and base64 encode it.
   string memory json = Base64.encode(
       bytes(
           string(
               abi.encodePacked(
                   '{"name": "',zodiacSign,
                   // We set the title of our NFT as the generated word.
                   '", "description": "On-chain Zodiac Sign NFTs", "attributes": [{"trait_type": "Zodiac Sign", "value": "',
                   zodiacSign,
                   '"}], "image": "data:image/svg+xml;base64,',
                   // We add data:image/svg+xml;base64 and then append our base64 encode our svg.
                   Base64.encode(bytes(finalSvg)),
                   '"}'
               )
           )
       )
   );

   // Just like before, we prepend data:application/json;base64, to our data.
   string memory finalTokenUri = string(
       abi.encodePacked("data:application/json;base64,", json)
   );

   uint256 newItemId = _tokenIds.current();
   _mint(recipient, newItemId);
   _setTokenURI(newItemId, finalTokenUri);

   return newItemId;
}
```

Let me explain the code step by step.

```
 string memory finalSvg = string(
        abi.encodePacked(baseSvg, zodiacSign, "</text></svg>")
    );
```

- Here we are just concatenating the `baseSvg`, the `zodiacSign`, and the end tags. Then we wrap it in string just to make sure that our final outcome is string type.

```
// Get all the JSON metadata in place and base64 encode it.
    string memory json = Base64.encode(
        bytes(
            string(
                abi.encodePacked(
                    '{"name": "',zodiacSign,
                    // We set the title of our NFT as the generated word.
                    '", "description": "On-chain Zodiac Sign NFTs", "attributes": [{"trait_type": "Zodiac Sign", "value": "',
                    zodiacSign,
                    '"}], "image": "data:image/svg+xml;base64,',
                    // We add data:image/svg+xml;base64 and then append our base64 encode our svg.
                    Base64.encode(bytes(finalSvg)),
                    '"}'
                )
            )
        )
    );
```

- We create our JSON structure and encode it in `base64`. Similarly, we populate `finalTokenURI` with JSON structure, encode it in `base64`, and declare the format to be JSON.

```
// Just like before, we prepend data:application/json;base64, to our data.
    string memory finalTokenUri = string(
        abi.encodePacked("data:application/json;base64,", json)
    );

```

## Complete code

Awesome! Phew!! The hardest part is over. This is what the final contract looks like.

```
// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "hardhat/console.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/utils/Base64.sol";

contract horoscopeNFT is ERC721URIStorage {
    uint256 private _tokenIds;

    string baseSvg = "<svg xmlns='<http://www.w3.org/2000/svg>' preserveAspectRatio='xMinYMin meet' viewBox='0 0 350 350'><style>.base { fill: white; font-family: serif; font-size: 24px; }</style><rect width='100%' height='100%' fill='black' /><text x='50%' y='50%' class='base' dominant-baseline='middle' text-anchor='middle'>";

    constructor() ERC721("Horoscope", "HSCP") {}

    function mintNFT(address recipient, string memory zodiacSign)
        public
        returns (uint256)
    {
        _tokenIds += 1;
        

        string memory finalSvg = string(
            abi.encodePacked(baseSvg, zodiacSign, "</text></svg>")
        );

        // Get all the JSON metadata in place and base64 encode it.
        string memory json = Base64.encode(
            bytes(
                string(
                    abi.encodePacked(
                        '{"name": "',zodiacSign,
                        // We set the title of our NFT as the generated word.
                        '", "description": "On-chain Zodiac Sign NFTs", "attributes": [{"trait_type": "Zodiac Sign", "value": "',
                        zodiacSign,
                        '"}], "image": "data:image/svg+xml;base64,',
                        // We add data:image/svg+xml;base64 and then append our base64 encode our svg.
                        Base64.encode(bytes(finalSvg)),
                        '"}'
                    )
                )
            )
        );

        // Just like before, we prepend data:application/json;base64, to our data.
        string memory finalTokenUri = string(
            abi.encodePacked("data:application/json;base64,", json)
        );

        uint256 newItemId = _tokenIds;
        _safeMint(recipient, newItemId);
        _setTokenURI(newItemId, finalTokenUri);
        return newItemId;
    }
}
```

Since we are encoding our JSON and SVG in Base64, we will need to import that file too from Openzeppelin using the `import "@openzeppelin/contracts/utils/Base64.sol";`. You can also download the file Base64 from [here](https://github.com/Metaschoolso/Learning-Projects/blob/main/Base64.sol) and add it to your contracts folder.

## That’s a wrap

Our function `mintNFT` is dynamic now, it takes the address and zodiac sign and then mints an NFT to the account.

Now, we will prepare for deployment.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/2.%20%F0%9F%92%BB%20Writing%20the%20NFT%20contract/2.%20Adding%20Image%20and%20Info%20to%20NFT.md

Adding Image and Info to NFT

<p style="margin-left:0px;">As NFTschool, describes it.</p><p style="margin-left:0px;">"There are three environments for a blockchain network: mainnet, devnet, and testnet.</p><h3 style="margin-left:0px;">devnet</h3><p style="margin-left:0px;">Till now we were using the local development network to run our smart contracts. This is the easiest and fastest way to get started, iterate and run things without having to setup tons of stuff. For setting up devnet, we used Hardhat that provided us a local ethereum like blockchain environment. Remember at the start of this project, I mentioned, how every time we deploy a smart contract it is a start from scratch. Now we are being promoted. Since we have setup a basic contract which we believe can run. We will use a testnet environment.</p><h3 style="margin-left:0px;">testnet</h3><p style="margin-left:0px;">Because devnets are a simplified simulation of the real network, they don’t always behave in quite the same way. This is a good thing when you want fast development cycles, but not so great when you want to know how your contract will actually work on mainnet.</p><p style="margin-left:0px;">For that, you can deploy and run your contract on a test network, or <em>testnet</em>. These networks generally run the same code as the mainnet, but they have separate blockchain states and may be configured differently in various ways.</p><h3 style="margin-left:0px;">mainnet</h3><p style="margin-left:0px;">The <em>mainnet</em> is the official production network. It is considered the source of truth, and its tokens can be exchanged for “real world” money in various ways. As you might imagine, using the mainnet for development and testing is an expensive proposition."</p><h3 style="margin-left:0px;">Setting up the testnet environment</h3><p style="margin-left:0px;">We will do the following things.</p><ul><li>Add Goerli network to Metamask</li><li>Get some fake ETH for the transaction</li><li>Create a Ethereum Goerli Network app on Alchemy</li><li>Update our hardhat.config.js file to include the goerli network.</li></ul><h4 style="margin-left:0px;">Changing your network on MetaMask</h4><p style="margin-left:0px;">We will not be using the live/production environment at the moment because it will be expensive to deploy a contract. You will need some real ETH to do that! And of course, learning and deploying contracts on production for the purpose of learning is not sustainable.</p><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://metaschool.s3-ap-southeast-1.amazonaws.com/images/FWxQXFSjxMyeasV0xvKZfQjWWh1Phg6nLOr95viK.png" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="FWxQXFSjxMyeasV0xvKZfQjWWh1Phg6nLOr95viK.png" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="0"></figure></div></figure><p></p><p style="margin-left:0px;">We will switch to Goerli Network, it is a test network which pretty much is a simulation of ethereum blockchain production. Just open chrome and switch your network to Goerli, if you are not able to see it.</p><p style="margin-left:0px;">Here are the steps to turn on test networks</p><ol><li>Go to settings</li><li>Open Advanced</li><li>Scroll down to Show Test Networks</li><li>Turn on</li></ol><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh3.googleusercontent.com/J1aA9vZcf8gE3h9ypNI2nQ0-wRypnCCCwNBDHtc7C9qcyzlkbOmlb6IDUxxN1xIwQpfIwSPZrmXy-C5hS65lcFIKg5U0LZaXhGw_y2QxGurmhwZSHcJwK0gk5KCaUpu45pmz8jl2" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="J1aA9vZcf8gE3h9ypNI2nQ0-wRypnCCCwNBDHtc7C9qcyzlkbOmlb6IDUxxN1xIwQpfIwSPZrmXy-C5hS65lcFIKg5U0LZaXhGw_y2QxGurmhwZSHcJwK0gk5KCaUpu45pmz8jl2" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="1"></figure></div></figure><p></p><h4 style="margin-left:0px;">&nbsp;</h4><h4 style="margin-left:0px;">Get some fake ETH $$ 🤑</h4><p style="margin-left:0px;">Try the following website and try to get some fake ETHs. 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 ETH.</p><p style="margin-left:0px;">All you have to do is to drop your public address on the following links and the ETH will be transferred.</p><ol><li><a href="https://www.goerlifaucet.com/" target="_blank" rel="noopener noreferrer"><u>https://www.goerlifaucet.com/</u></a>&nbsp;</li></ol><h4 style="margin-left:0px;">Get your private 🦊 MetaMask key</h4><p style="margin-left:0px;">Open the Metamask extension to find your private 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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history.</p><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://metaschool.s3-ap-southeast-1.amazonaws.com/images/xR90oDFgwFLgOIN03aIlqFhEpxUhF7R0sS9aBFCR.png" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="xR90oDFgwFLgOIN03aIlqFhEpxUhF7R0sS9aBFCR.png" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="2"></figure></div></figure><p></p><p style="margin-left:0px;">I will tell you how to keep your account and private key safe in the next steps. For now, export private it and paste it somewhere secure. DON’T COMMIT IT ON GITHUB, DONT SHARE IT ON DISCORD, DON’T SHARE IT ANYWHERE! IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUND AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.</p><p style="margin-left:0px;">BE EXTRAAA VIGILANT!!</p><h4 style="margin-left:0px;"><strong>Creating Quick Node ⛓ endpoint</strong></h4><p>Now, we need to set up <a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer">QuickNode</a> with Ethereum testnet nodes, it’s gonna take like 5 mins.</p><p>QuickNode is a platform which helps you access the blockchain environment without going through the hassle of hosting your own node, saving time and resources. This platform lets you access blockchain nodes in a few clicks and you can scale the node performance according to your need thus creating an environment for you to scale your DApp.</p><ul><li>Sign in / Sign up to your<a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer">&nbsp;<strong><u>QuickNode</u></strong></a> account</li><li>Click on create an&nbsp;<a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer"><strong>QuickNode</strong></a> endpoint&nbsp;</li></ul><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh4.googleusercontent.com/nusZ81aRnb8ue5J6qJLN29NG-lQRe-oQcxoeHyplNrA2IpLKg3cBC2tXPE0XXg2JEI1ugLuCX-fSNFYdtJIctMYW9hLWo7jsQxun7aQU6w_0w1Hqb3Md6lMf1Q9bM57zAm0xKmNDzqCNghdNwYHetosBTnWTnmgCLKUarXGyuUs-EHxBKdN33yEVChkU-HQCo0RUCw" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="nusZ81aRnb8ue5J6qJLN29NG-lQRe-oQcxoeHyplNrA2IpLKg3cBC2tXPE0XXg2JEI1ugLuCX-fSNFYdtJIctMYW9hLWo7jsQxun7aQU6w_0w1Hqb3Md6lMf1Q9bM57zAm0xKmNDzqCNghdNwYHetosBTnWTnmgCLKUarXGyuUs-EHxBKdN33yEVChkU-HQCo0RUCw" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="3"></figure></div><p><br></p><ul><li>Now select Ethereum as Network and Goerli as chain and continue</li><li>We don’t need any add-on so click&nbsp;<strong>create endpoint</strong> now</li></ul><p>Now once you create the endpoint you can start setting up our Metamask Wallet with QuickNode. Now let’s move to the next part! Hope this was really easy for you to understand!</p><ul><li>Go to your Metamask wallet and click on the list of networks.</li></ul><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh5.googleusercontent.com/2UexuPf9TiOmgJskf1KjXbksBlQwnTvRS0tU_nzrKg_3wc4hzVAX4SDqifH3y8YyTb2YJIb2NVQEF_ShIkATyplBcz5_zrzxWuKkodQs5h2JJhUWuo4I0kIRECG1evY510WYAJlbc6W9DyTBVb3gCn9KYAi8ECYR_4tMGer7RBrxErQ8-PpNpOYCrNYj6FrRWD5LrQ" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="2UexuPf9TiOmgJskf1KjXbksBlQwnTvRS0tU_nzrKg_3wc4hzVAX4SDqifH3y8YyTb2YJIb2NVQEF_ShIkATyplBcz5_zrzxWuKkodQs5h2JJhUWuo4I0kIRECG1evY510WYAJlbc6W9DyTBVb3gCn9KYAi8ECYR_4tMGer7RBrxErQ8-PpNpOYCrNYj6FrRWD5LrQ" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="4"></figure></div><p><br></p><ul><li>A drop-down list will show up with a list of networks but you need to click on&nbsp;<strong>ADD NETWORK</strong> at the bottom of the list</li><li>Now you will have a form to fill up to add a new network to your metamask account</li><li>Let’s go back to QuickNode Endpoint Dashboard, and copy the HTTPS</li></ul><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh3.googleusercontent.com/rVD2taxs_lfShmW29I27PatQTIx9NZLnBIA3nGnyKye4Q2WQM_tiC8XpeWHCxu5g6irMWCZm6TnD3LqFhrcmwCFIWXAlnqrPoTmBB8XSiaDerKm7PvbNy625amuVm-vutlS8uyb8A1V0RxEdmtDEKDRaq_4X70LClb42guWZVyX-XCrm7htvkcFPwDAPDJMN2acgbg" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="rVD2taxs_lfShmW29I27PatQTIx9NZLnBIA3nGnyKye4Q2WQM_tiC8XpeWHCxu5g6irMWCZm6TnD3LqFhrcmwCFIWXAlnqrPoTmBB8XSiaDerKm7PvbNy625amuVm-vutlS8uyb8A1V0RxEdmtDEKDRaq_4X70LClb42guWZVyX-XCrm7htvkcFPwDAPDJMN2acgbg" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="5"></figure></div><p><br></p><p>Now let’s go back to the Metamask add network form and&nbsp;</p><ul><li>Paste the HTTPS in&nbsp;<strong>New RPC Url</strong> field with 5 as&nbsp;<strong>Chain ID</strong>,&nbsp;</li><li>“ETH” as&nbsp;<strong>Currency Symbol</strong>,&nbsp;</li><li>Ethereum Goerli as&nbsp;<strong>Network Name (Any name as you like)</strong> and&nbsp;</li><li>Finally&nbsp;<a href="https://goerli.etherscan.io/%20"><u>https://goerli.etherscan.io/</u></a> as&nbsp;<strong>Block Explorer URL.</strong>&nbsp;</li><li>Click Save</li></ul><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh3.googleusercontent.com/NxmZPfEJiinySOv3C9APrka5wQATNH-_6XZr2ncTwDNEP6R7liepAkwQ1ApvGZGKVO3pKAndmI7X1SFyO88LrkTmL19pTlIvSZ1xsaXGjZaOo7VTUb7NLorC1Lp3wDjUXkK1oYqLlMsq94NBPDE6Ejv5Z7UvKmG80YMlZ8fQZSMGJ48Xvin122CSeYhDFckwB3wXiA" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="NxmZPfEJiinySOv3C9APrka5wQATNH-_6XZr2ncTwDNEP6R7liepAkwQ1ApvGZGKVO3pKAndmI7X1SFyO88LrkTmL19pTlIvSZ1xsaXGjZaOo7VTUb7NLorC1Lp3wDjUXkK1oYqLlMsq94NBPDE6Ejv5Z7UvKmG80YMlZ8fQZSMGJ48Xvin122CSeYhDFckwB3wXiA" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="6"></figure></div><p><br></p><ul><li>So, we have finished setting up metamask for our token, now let’s get some free ETH tokens to pay for the transaction fees.</li></ul>

# Deploying and Testing the NFT contract

Early on we deployed our contract locally. Now, in this lesson we will deploy our NFT contract to a blockchain network.

## Blockchain network

As NFTschool, describes it: “There are three environments for a blockchain network: mainnet, devnet, and testnet.”

### devnet

Till now we have been using the local development network to run our smart contracts. This is the easiest and fastest way to get started, iterate, and run things without having to set up tons of stuff. For setting up devnet, we used Hardhat which provided us with a local Ethereum-like blockchain environment. Remember at the start of this project, I mentioned, how every time we deploy a smart contract it is a start from scratch. Now we are being promoted. Since we have set up a basic contract which we believe can run. We will use a testnet environment.

### testnet

Because devnet is a simplified simulation of the real network, they don’t always behave in quite the same way. This is a good thing when you want fast development cycles, but not so great when you want to know how your contract will actually work on mainnet.

For that, you can deploy and run your contract on a test network, or  *testnet*. These networks generally run the same code as the mainnet, but they have separate blockchain states and may be configured differently in various ways.

### mainnet

The *mainnet* is the official production network. It is considered the source of truth, and its tokens can be exchanged for “real world” money in various ways. As you might imagine, using the mainnet for development and testing is an expensive proposition."

## Setting up the testnet environment

Complete the following steps:

- Head over to [https://chainlist.org/chain/80002](https://chainlist.org/chain/80002).
- 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 Amoy network.

## Get some fake MATIC

Now it's time to get some money! 

- Head over to [https://faucet.polygon.technology/](https://faucet.polygon.technology/).
- Make sure you select "Amoy" network.
- Copy your account address.
- Paste your wallet address.
- Click on Submit button.
- Wait for a few seconds, you will receive 0.2 MATIC.

See in the following gif how I did it:
![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/assests_for_horoscope/webp%20images%20new/image-missing.webp)


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_horoscope/2.%20Writing%20and%20Deploying%20Basic%20Contract/3.%20Deploying%20and%20Testing%20NFT%20contract/Screen_Recording_2023-08-02_at_7.28.24_PM.webp?raw=true)

I will tell you how to keep your account and private key safe in the next lesson. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. DON’T COMMIT IT ON GITHUB, DON'T SHARE IT ON DISCORD, DON’T SHARE IT ANYWHERE! IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUNDS AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.

BE EXTRAAA VIGILANT!!

## Create `.env` file

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

```
PRIVATE_KEY="<YOUR_PRIVATE_KEY>"
```

## That’s a wrap

In this lesson, we learned about the different environments for blockchain networks and how to set up a testnet environment for deploying and testing NFT contracts. We also learned about the importance of keeping private keys secure and not sharing them publicly. Remember to always be vigilant and keep your keys safe!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/2.%20%F0%9F%92%BB%20Writing%20the%20NFT%20contract/3.%20Deploying%20and%20Testing%20NFT%20contract.md

Deploying and Testing NFT contract

<p style="margin-left:0px;">First let’s do some basic housekeeping stuff. We know that there are massive scams and security issues happening in the crypto world. You make a mistake and it can cost you a life time.</p><p style="margin-left:0px;">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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.</p><pre><code>npm install dotenv --savetouch .gitignore</code></pre><p style="margin-left:0px;">🔥 This is super important! 🔥&nbsp;<br><br>Go ahead and create .env file at the root of your project. Yes. Your file name would be .env!&nbsp;<br><br>Then, open your .gitignore file and write .env there. <a href="https://github.com/Metaschoolso/Learning-Projects/blob/main/.env-sample" target="_blank" rel="noopener noreferrer">Here is a sample .env file that you can replicate.</a></p><p style="margin-left:0px;">All the secrets and important keys related to your project will be stored in .env file and we can access this data whenever and wherever. In the gitignore file we simply write .env, it tells git to ignore that file from future commits.</p><p style="margin-left:0px;">Open the .env file you have just created. Add your MetaMask Private Key and Alchemy App HTTP URL there. Should be something like this<span style="background-color:rgb(255,255,255);color:rgb(102,102,102);">.&nbsp;</span></p><pre><code>PRIVATE_KEY = YOUR_PRIVATE_KEYAPI_URL_KEY = YOUR_QUICKNODE_HTTP_URL</code></pre><p style="margin-left:0px;">We will update our hardhat config file to setup Goerli Deployment.</p><h4 style="margin-left:0px;">Updating Hardhat Config file</h4><p style="margin-left:0px;">Open your hardhat.config.js file and paste the following code and add your Metamask Private Key and Quick Node HTTP URL there.</p><pre><code>/** * @type import('hardhat/config').HardhatUserConfig */ require('dotenv').config(); //all the key value pairs are being made available due to this lib require("@nomicfoundation/hardhat-toolbox");     module.exports = {   solidity: "0.8.17",   defaultNetwork: 'goerli',   networks: {     hardhat: {},     goerli: {         url: process.env.API_URL_KEY,         accounts: [`0x${process.env.PRIVATE_KEY}`]     }   } };</code></pre><p>&nbsp;</p><h3 style="margin-left:0px;">Deployment</h3><p style="margin-left:0px;">Now you are ready to deploy your contract to Goerli network. The command is almost same as before but now you will mention the goerli network where you are deploying your contract.</p><p style="margin-left:0px;">Wait a second. We need to update our <strong>deploy.js file too.</strong></p><pre><code>const hre = require("hardhat");  async function main() {       const horoscopeNFT = await hre.ethers.getContractFactory("horoscopeNFT");    const hscp = await horoscopeNFT.deploy();       await hscp.deployed();     //since we are testing, you should mention your own Eth wallet address    const myAddress="ETHEREUM_ADDRESS_WHERE_YOU_WANT_TO_MINT";    console.log("horoscopeNFT deployed to:", hscp.address);        let txn = await hscp.mintNFT(myAddress, 'virgo');    await txn.wait(); } main()    .then(() =&gt; process.exit(0))      .catch((error) =&gt; {        console.error(error);    process.exit(1);  });</code></pre><p style="margin-left:0px;">This is what we are doing in our deployment script. By using Hardhat ethers plugin, we create an instance of our contract and deploy it.</p><pre><code>const horoscopeNFT = await hre.ethers.getContractFactory("horoscopeNFT");const hscp = await horoscopeNFT.deploy();   await hscp.deployed();</code></pre><p style="margin-left:0px;">Once the contract is deployed. We call the mintNFT function by passing it our wallet address and a string ‘virgo’ horoscope sign to call the mint function.</p><pre><code>let txn = await hscp.mintNFT(myAddress, 'virgo');await txn.wait();</code></pre><p style="margin-left:0px;">Let’s run the command in our terminal and run this project.</p><pre><code>npx hardhat run scripts/deploy.js --network goerli</code></pre><p style="margin-left:0px;">Once your contract is deployed. You can do the following things.</p><p style="margin-left:0px;">Copy your contract address and scan it on <a href="https://goerli.etherscan.io/" target="_blank" rel="noopener noreferrer"><u>Goerli Etherscan</u></a>. The contract address must have appeared on terminal because of console log. You will also be able to see that the mint function is called.&nbsp;<br><br></p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh4.googleusercontent.com/2Ph_o-c7wo9Zd5u5dIZbDE9BjVvH32NyWlk6Q599cpo8pDxXT3-6LV-j2WmrJsDna0jUN0W19oEER67sCX6ekgGTFqvYNzAB045FTiE4Xxa3oWEx-VTY4vJ-h0G5WcsOzEE1irgQ" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="2Ph_o-c7wo9Zd5u5dIZbDE9BjVvH32NyWlk6Q599cpo8pDxXT3-6LV-j2WmrJsDna0jUN0W19oEER67sCX6ekgGTFqvYNzAB045FTiE4Xxa3oWEx-VTY4vJ-h0G5WcsOzEE1irgQ" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="0"></figure></div><p style="margin-left:0px;"><br></p><p style="margin-left:0px;">Copy the contract address and open <a href="http://testnets.opensea.io/" target="_blank" rel="noopener noreferrer"><u>testnets.opensea.io</u></a>. You will be able to see your collection, and one NFT minted there.</p><p style="margin-left:0px;">Just like etherscan, there is a <a href="https://goerli.etherscan.io/" target="_blank" rel="noopener noreferrer"><u>goerli.etherscan.io</u></a>. This is to help you track your smart contracts and transaction. You can open goerli testnet and copy paste your deployed contract to see if it is correctly deployed.</p><p style="margin-left:0px;">🚨 Go back to your .env file. Save your deployed contract address there, we will need it later.&nbsp;<br>&nbsp;</p><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://lh3.googleusercontent.com/CVO_LcaGOwQJw9BR5edwUCcBZfJflF2ldjlidLvrs6bxCZA-DcmsL1CK-5hecjKDLTOixOTPgPMWOydDo0867BWEANEA_4NhFzw2tYV2E5Ghz3RdsZPWFDNdKxKI5h4Afrodmwfn" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="CVO_LcaGOwQJw9BR5edwUCcBZfJflF2ldjlidLvrs6bxCZA-DcmsL1CK-5hecjKDLTOixOTPgPMWOydDo0867BWEANEA_4NhFzw2tYV2E5Ghz3RdsZPWFDNdKxKI5h4Afrodmwfn" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="1"></figure></div></figure><p></p><p style="margin-left:0px;">Here is the direct opensea collection link.</p><p style="margin-left:0px;"><a href="https://testnets.opensea.io/collection/horoscope-nft-29vnjsvkxb" target="_blank" rel="noopener noreferrer"><u>OpenSea Collection</u></a></p><p style="margin-left:0px;">Phew!!! We are 80% done. You should be proud of yourself. You started from scratch and now you have your own collection of NFT minted on testnet. I think you should talk about it on Twitter, LinkedIn, Discord. In short anywhere you can humble brag a bit and tell people that your are doing amazing stuff on Web3.</p><p style="margin-left:0px;">While you are at it, don’t forget to mention <a href="https://twitter.com/0xmetaschool" target="_blank" rel="noopener noreferrer"><u>@0xmetaschool</u></a> on twitter. We need your support to reach more devs.</p><p><strong>Maybe, let's go back to our </strong><a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer"><strong>Quicknode</strong></a><strong> dashboard and check if our node is working or not?</strong></p><p><strong>Go to your Quicknode dashboard and click on metrics and check if you have any activity</strong></p><p></p><figure class="image"><div class="se-component se-image-container __se__float-none" contenteditable="false"><figure class="image" style="margin: 0px;"><img src="https://metaschool.s3-ap-southeast-1.amazonaws.com/images/wMLM1FGFDOVwZ2FNG6jUSjzhi4UNApZeNSe1hkg3.png" data-origin="," alt="" data-proportion="true" data-align="none" data-file-name="wMLM1FGFDOVwZ2FNG6jUSjzhi4UNApZeNSe1hkg3.png" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" style="" data-index="2"></figure></div></figure><p></p>

# Last Steps for Deployment

Greetings! So did a great job in setting the testnet. Let’s finally deploy our NFT on it now!

## Last steps for deployment

First, let’s do some basic housekeeping stuff. We know that there are massive scams and security issues happening in the crypto world. You make a mistake and it can cost you a lifetime.

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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.

```
npm install dotenv --save
```

🔥 This is super important! 🔥

We have created a `.env` file. Open your `.gitignore` file and write `.env` there.  [Here is a sample .env file that you can replicate.](https://github.com/Metaschoolso/Learning-Projects/blob/main/.env-sample) 

All the secrets and important keys related to your project will be stored in a `.env` file and we can access this data whenever and wherever. In the `.gitignore` file we simply write `.env`, and it tells git to ignore that file from future commits.

We will update our hardhat config file.

## Updating Hardhat Config file

Open your `hardhat.config.js` file and paste the following code.

```
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();
const {PRIVATE_KEY } = process.env;
module.exports = {
   solidity: "0.8.20",
   defaultNetwork: "amoy",
   networks: {
     hardhat: {},
     amoy: {
       url: "https://rpc.ankr.com/polygon_amoy",
       accounts: [`0x${PRIVATE_KEY}`],
     },
   },
};
```

## Deployment

Now you are ready to deploy your contract to the Polygon network. The command is the same as before. Wait a second. We need to update our `scripts/deploy.js` file too with the following code.

```
async function main() {
  const Horoscope = await ethers.deployContract("contracts/horoscopeNFT.sol:horoscopeNFT");
  const horoscope = await Horoscope.waitForDeployment();
  console.log("Deploying Contract...")
  console.log("Contract deployed to address:",  await horoscope.getAddress());
}
// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

This is what we are doing in our deployment script. By using the HardHat ethers plugin, we create an instance of our contract and deploy it.

```
	const Horoscope = await ethers.getContractFactory("contracts/horoscopeNFT.sol:horoscopeNFT");
  console.log("Deploying Contract...")
  const horoscope = await Horoscope.deploy();
```

Let’s run the command in our terminal and run this project.

```
npx hardhat run scripts/deploy.js
```

Once your contract is deployed, you can see an output similar to below:

![Screen Shot 2023-08-02 at 8.24.28 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/2.%20Writing%20and%20Deploying%20Basic%20Contract/4.%20Last%20Steps%20for%20Deployment/Screen_Shot_2023-08-02_at_8.24.28_PM.webp?raw=true)

## Interact with your contract

Copy your contract address and scan it on [**https://amoy.polygonscan.com/**](https://amoy.polygonscan.com/). And this is how it looks:

![Screen Shot 2023-08-02 at 8.25.30 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/2.%20Writing%20and%20Deploying%20Basic%20Contract/4.%20Last%20Steps%20for%20Deployment/Screen_Shot_2023-08-02_at_8.25.30_PM.webp?raw=true)

## That’s a wrap

Phew!!! We are 80% done. You should be proud of yourself. You started from scratch and now you have your own collection of NFT minted on testnet. I think you should talk about it on Twitter, LinkedIn, Discord. In short anywhere you can humble brag a bit and tell people that you are doing amazing stuff on Web3.

While you are at it, don’t forget to mention  [@0xmetaschool](https://twitter.com/0xmetaschool)  on Twitter. We need your support to reach more devs.

In the next lesson, we will be building the front end of our app.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/2.%20%F0%9F%92%BB%20Writing%20the%20NFT%20contract/4.%20Last%20Steps%20for%20Deployment.md

Last Steps for Deployment

<p style="margin-left:0px;">So far we have created an NFT contract, pushed it to testnet and we called its function MintNFT to mint a horoscope card to the address. We provided these values to our project statically. There was no front end, which makes the whole process boring.</p><p style="margin-left:0px;">So lets get to creating our react app and creating a frontend that can trigger our published contract. We will do the following.</p><ol><li>Create a react app.</li><li>Allow user to connect their metamask wallet</li><li>A date picker to select date of birth.</li><li>A mint button to call our contract and mint the NFT.</li></ol><h2 style="margin-left:0px;">Building the react app</h2><p style="margin-left:0px;">First we will create a basic react application, and then we will add a connect to MetaMask button. The application will also check if MetaMask extension is installed or not. If it is not installed, the application will display a message to download the extension.</p><p style="margin-left:0px;">Once the account is connected, we will display the connected account address. <em><strong>We will create a separate project for this.</strong></em></p><p style="margin-left:0px;">Let’s get to coding first. Fire your terminal and write the following instructions:</p><pre><code>npx create-react-app horoscopeweb3</code></pre><p style="margin-left:0px;">Go ahead and write the following command.</p><pre><code>cd horoscopeweb3/    npm start</code></pre><p style="margin-left:0px;">This will start your server and automatically open a window for you, where you can see the default react app.</p><p style="margin-left:0px;">In the next section, we will edit the react app.</p><h2 style="margin-left:0px;">Connecting MetaMask wallet</h2><p style="margin-left:0px;">Now open the src/App.js file. This is where we will make our edits.</p><p style="margin-left:0px;">We will add the following dependencies in your App.js file. Go ahead and add the following imports.</p><pre><code>import { useEffect, useState } from "react";import { Contract, providers } from "ethers";</code></pre><p style="margin-left:0px;">At this point, you will see an error message in your browser that ethers is not recognized. In the terminal write the following command.</p><pre><code>npm i ethers</code></pre><p style="margin-left:0px;">This is to install ethers.js for your project. So what is ethers.js? The ethers. js library aims to be a complete and compact library for interacting with the Ethereum Blockchain and its ecosystem. In our project, we will use this library to create instances of our contracts and execute their functions.</p><p style="margin-left:0px;">Next we will do some housekeeping stuff by using React’s useState hook to keep track</p><ol><li>If the user has installed MetaMask wallet.</li><li>If the user has connected their account of metamask already</li></ol><p style="margin-left:0px;">In the function app() section, add the following lines. Go ahead and copy paste these and I will explain the code.</p><pre><code>const [isWalletInstalled, setIsWalletInstalled] = useState(false);const [account, setAccount] = useState(null);   useEffect(() =&gt; {      if (window.ethereum) {        setIsWalletInstalled(true);      }    }, []);   async function connectWallet() {    window.ethereum      .request({        method: "eth_requestAccounts",      })      .then((accounts) =&gt; {        setAccount(accounts[0]);      })      .catch((error) =&gt; {        alert("Something went wrong");      });  }</code></pre><p style="margin-left:0px;">useState is a Hook that allows you to have state variables in functional components. You pass the initial state to this function and it returns a variable with the current state value (not necessarily the initial state) and another function to update this value. We are starting with a false state for if the wallet is installed. And a null state for if an account is connected.</p><p style="margin-left:0px;">When you call useEffect , you’re telling React to run your “effect” function after flushing changes to the DOM. Effects are declared inside the component so they have access to its props and state. By default, React runs the effects after every render — including the first render.</p><p style="margin-left:0px;">MetaMask injects a global API into websites visited by its users at window.ethereum. This API allows websites to request users’ Ethereum accounts, read data from blockchains the user is connected to, and suggest that the user sign messages and transactions. The function connectWallet simply does a remote procedure call to Ethereum via MetaMask. It returns a Promise that resolves to the result of the method call.</p><p style="margin-left:0px;">Now we will remove all the default front end elements and replace them with the following code.</p><pre><code>if (account === null) {  return (    &lt;div className="App"&gt;      {         isWalletInstalled ? (          &lt;button onClick={connectWallet}&gt;Connect Wallet&lt;/button&gt;        ) : (          &lt;p&gt;Install Metamask wallet&lt;/p&gt;        )      }     &lt;/div&gt;  );}  return (    &lt;div className="App"&gt;       &lt;p&gt;Connected as: {account}&lt;/p&gt;    &lt;/div&gt;  );}</code></pre><p style="margin-left:0px;">The code simply checks first if the metamask account is already connected with the website. If connected, it shows the connected account address.</p><p style="margin-left:0px;">If the account is not connected, it first checks if MetaMask is installed in the browser. If it is not installed, we show a message to install the wallet. Else, we show a button to Connect Wallet.</p><p style="margin-left:0px;">There is also an OnClick function that triggers the connectWallet function.</p><p style="margin-left:0px;">That’s all folks, we are ready to check. By now your code looks something like this.</p><pre><code>import logo from './logo.svg';import './App.css';import { useEffect, useState } from "react";import { Contract, providers } from "ethers"; function App() {  const [isWalletInstalled, setIsWalletInstalled] = useState(false);  const [account, setAccount] = useState(null);  useEffect(() =&gt; {   if (window.ethereum) {     setIsWalletInstalled(true);   } }, []);  async function connectWallet() {   window.ethereum     .request({       method: "eth_requestAccounts",     })     .then((accounts) =&gt; {       setAccount(accounts[0]);     })     .catch((error) =&gt; {       alert("Something went wrong");     }); }   if (account === null) {     return (       &lt;div className="App"&gt;         {           isWalletInstalled ? (             &lt;button onClick={connectWallet}&gt;Connect Wallet&lt;/button&gt;           ) : (             &lt;p&gt;Install Metamask wallet&lt;/p&gt;           )         }        &lt;/div&gt;     );   }     return (       &lt;div className="App"&gt;        &lt;h1&gt;Horoscope NFT Minting Dapp&lt;/h1&gt;        &lt;p&gt;Connected as: {account}&lt;/p&gt;    &lt;/div&gt;   ); } export default App;</code></pre><p style="margin-left:0px;">Go ahead and run the following command in the terminal.</p><pre><code>npm start</code></pre><p style="margin-left:0px;">Everything should run smoothly. Congrats for building this mini project and following through the instructions. :)</p>

# Connecting the MetaMask wallet

So far we have created an NFT contract, pushed it to testnet and we called its function `MintNFT` to mint a horoscope card to the address. We provided these values to our project statically. There was no front end, which makes the whole process boring.

So lets get to creating our react app and creating a frontend that can trigger our published contract. We will do the following.

1. Create a react app.
2. Allow user to connect their MetaMask wallet
3. A date picker to select date of birth.
4. A mint button to call our contract and mint the NFT.

## Building the react app

First we will create a basic react application, and then we will add a “Connect to MetaMask” button. The application will also check if MetaMask extension is installed or not. If it is not installed, the application will display a message to download the extension.

Once the account is connected, we will display the connected account address.  

**Note: We will create a separate project for this.**

Let’s get to coding first. Fire your terminal and write the following instructions:

```
npx create-react-app horoscopeweb3
```

You will get the following output along with other messages after creating the app.

```
Success! Created horoscopeweb3
```

Here’s what the folder structure will look like.

![Frame 3560339 (7).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/3.%20Creating%20the%20React%20App/1.%20Connecting%20the%20MetaMask%20wallet/Frame_3560339_(7).webp?raw=true)

Go ahead and write the following command.

```
cd horoscopeweb3/
npm start
```

This will start your server and automatically open a window for you, where you can see the default react app. The app will look like this:

![Frame 3560339 (5).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/3.%20Creating%20the%20React%20App/1.%20Connecting%20the%20MetaMask%20wallet/Frame_3560339_(5).webp?raw=true)

In the next section, you will edit the React app.

## Connecting MetaMask wallet

Now open the `src/App.js` file and remove any existing imports. This is where we will make our edits.

- First, we will add the following dependencies to your `App.js` file. Go ahead and add the following imports.

```
import { useEffect, useState } from "react";
import { Contract, providers } from "ethers";
import NFT from "./abi/horoscopeNFT.json";
```

- If your app is still running in the terminal, you will see an error message in your browser that ethers is not recognized.
- In the separate terminal write the following command.

```
npm i ethers
```

This is to install `ethers.js` for your project. So what is `ethers.js`? 

- The `ethers.js` library aims to be a complete and compact library for interacting with the Ethereum Blockchain and its ecosystem.
- In our project, we will use this library to create instances of our contracts and execute their functions.

Next, we will do some housekeeping stuff by using React’s `useState` hook to keep track.

1. If the user has installed the MetaMask wallet.
2. If the user has connected their account to MetaMask already.

In the function `app()`, add the following lines. Go ahead and copy and paste these and I will explain the code.

```
const [isWalletInstalled, setIsWalletInstalled] = useState(false);
const [account, setAccount] = useState(null);

  useEffect(() => {
      if (window.ethereum) {
        setIsWalletInstalled(true);
      }
    }, []);

  async function connectWallet() {
    window.ethereum
      .request({
        method: "eth_requestAccounts",
      })
      .then((accounts) => {
        setAccount(accounts[0]);
      })
      .catch((error) => {
        alert("Something went wrong");
      });
  }

```

- `useState` is a Hook that allows you to have state variables in functional components.
- You pass the initial state to this function and it returns a variable with the current state value (not necessarily the initial state) and another function to update this value.
- We are starting with a false state if the wallet is installed. And a null state if an account is connected.
- When you call `useEffect`, you’re telling React to run your `effect` function after flushing changes to the DOM.
- Effects are declared inside the component so they have access to its props and state. By default, React runs the effects after every render — including the first render.
- MetaMask injects a global API into websites visited by its users at `window.ethereum`.
- This API allows websites to request users’ Ethereum accounts, read data from blockchains the user is connected to, and suggest that the user sign messages and transactions.
- The function `connectWallet` simply does a remote procedure call to Ethereum via MetaMask. It returns a Promise that resolves to the result of the method call.

Now we will remove all the default front-end elements and replace them with the following code.

```
if (account === null) {
  return (
    <div className="App">
      {
        isWalletInstalled ? (
          <button onClick={connectWallet}>Connect Wallet</button>
        ) : (
          <p>Install Metamask wallet</p>
        )
      }

    </div>
  );
}
  return (
    <div className="App">
      <p>Connected as: {account}</p>
    </div>
  );
}

```

- The code simply checks first if the MetaMask account is already connected to the website.
- If connected, it shows the connected account address.
- If the account is not connected, it first checks if MetaMask is installed in the browser.
- If it is not installed, we show a message to install the wallet. Else, we show a button to Connect Wallet.
- There is also an `OnClick` function that triggers the `connectWallet` function.

## Complete code

That’s all folks, we are ready to check. By now your code looks something like this.

```
import logo from './logo.svg';
import './App.css';
import { useEffect, useState } from "react";
import { Contract, providers } from "ethers";

function App() {
  const [isWalletInstalled, setIsWalletInstalled] = useState(false);
  const [account, setAccount] = useState(null);

 useEffect(() => {
   if (window.ethereum) {
     setIsWalletInstalled(true);
   }
 }, []);

 async function connectWallet() {
   window.ethereum
     .request({
       method: "eth_requestAccounts",
     })
     .then((accounts) => {
       setAccount(accounts[0]);
     })
     .catch((error) => {
       alert("Something went wrong");
     });
 }
   if (account === null) {
     return (
       <div className="App">
         {
           isWalletInstalled ? (
             <button onClick={connectWallet}>Connect Wallet</button>
           ) : (
             <p>Install Metamask wallet</p>
           )
         }

       </div>
     );
   }
     return (
       <div className="App">
        <h1>Horoscope NFT Minting Dapp</h1>
        <p>Connected as: {account}</p>
    </div>
   );
 }

export default App;

```

## Run your app

Go ahead and run the following command in the terminal to run your app again.

```
npm start

```

Everything should run smoothly. 

## That’s a wrap

Congrats on building this mini-project and following through with the instructions. :) In the next lesson, you will continue building the `App()` and more functionalities to it.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/3.%20%F0%9F%91%91%20Creating%20the%20React%20App/1.%20Connecting%20the%20MetaMask%20wallet.md

Connecting the MetaMask wallet

<p style="margin-left:0px;">Here is a good demo of our app and this is how our application is going to look like. So let’s get to building that.</p><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/6e853f9f0e3b42d1900b77c5a4a592a7"><div class="se-component se-video-container __se__float-" style="width: 100%;" contenteditable="false"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/6e853f9f0e3b42d1900b77c5a4a592a7" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="6e853f9f0e3b42d1900b77c5a4a592a7" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p><p style="margin-left:0px;">Let’s make some changes to the UI first. This is the basic HTML code with some listeners.</p><pre><code>if (account === null) { return (   &lt;div className="App"&gt; &lt;br/&gt;     {       isWalletInstalled ? (         &lt;button onClick={connectWallet}&gt;Connect Wallet&lt;/button&gt;       ) : (         &lt;p&gt;Install Metamask wallet&lt;/p&gt;       )     }    &lt;/div&gt; );   }     return (       &lt;div className="App"&gt;       &lt;h1&gt;Horoscope NFT Minting Dapp&lt;/h1&gt;       &lt;p&gt;Connected as: {account}&lt;/p&gt;    &lt;input onChange={handleDateInput} value={date} type="date" id="dob"/&gt;   &lt;br /&gt;   &lt;br /&gt;     {zodiacSign ? (     &lt;svg       xmlns="http://www.w3.org/2000/svg"       preserveAspectRatio="xMinYMin meet"       viewBox="0 0 300 300"       width="400px"       height="400px"     &gt;       &lt;style&gt;{`.base { fill: white; font-family: serif; font-size: 24px;`}&lt;/style&gt;       &lt;rect width="100%" height="100%" fill="black" /&gt;       &lt;text         x="50%"         y="50%"         class="base"         dominant-baseline="middle"         text-anchor="middle"       &gt;         {zodiacSign}       &lt;/text&gt;     &lt;/svg&gt;   ) : null}        &lt;br/&gt;       &lt;br/&gt;       &lt;button&gt;Mint&lt;/button&gt;   &lt;/div&gt;  );}</code></pre><p style="margin-left:0px;">Now we will add some functions, hooks etc in the function App(). Just copy paste it in your application and I will explain it step by step.</p><pre><code>// state to keep track whether the user has installed wallet or not.const [isWalletInstalled, setIsWalletInstalled] = useState(false);const [date, setDate] = useState("1970-01-01"); // state for zodiacSign derived from date.const [zodiacSign, setZodiacSign] = useState(null); // state for keeping track of current connected account.const [account, setAccount] = useState(null); // state for whether app is minting or not.const [isMinting, setIsMinting] = useState(false); const [NFTContract, setNFTContract] = useState(null); useEffect(() =&gt; {    calculateZodiacSign(date);}, [date]); useEffect(() =&gt; {    if (window.ethereum) {        setIsWalletInstalled(true);    }}, []); async function connectWallet() {    window.ethereum        .request({            method: "eth_requestAccounts",        })        .then((accounts) =&gt; {            setAccount(accounts[0]);        })        .catch((error) =&gt; {            alert("Something went wrong");        });} function handleDateInput({ target }) {    setDate(target.value);} function calculateZodiacSign(date) {    let dateObject = new Date(date);    let day = dateObject.getDate();    let month = dateObject.getMonth();    if (month == 0) {        if (day &gt;= 20) {            setZodiacSign("Aquarius");        } else {            setZodiacSign("Capricorn");        }    } else if (month == 1) {        if (day &gt;= 19) {            setZodiacSign("Pisces");        } else {            setZodiacSign("Aquarius");        }    } else if (month == 2) {        if (day &gt;= 21) {            setZodiacSign("Aries");        } else {            setZodiacSign("Pisces");        }    } else if (month == 3) {        if (day &gt;= 20) {            setZodiacSign("Taurus");        } else {            setZodiacSign("Aries");        }    } else if (month == 4) {        if (day &gt;= 21) {            setZodiacSign("Gemini");        } else {            setZodiacSign("Taurus");        }    } else if (month == 5) {        if (day &gt;= 21) {            setZodiacSign("Cancer");        } else {            setZodiacSign("Gemini");        }    } else if (month == 6) {        if (day &gt;= 23) {            setZodiacSign("Leo");        } else {            setZodiacSign("Cancer");        }    } else if (month == 7) {        if (day &gt;= 23) {            setZodiacSign("Virgo");        } else {            setZodiacSign("Leo");        }    } else if (month == 8) {        if (day &gt;= 23) {            setZodiacSign("Libra");        } else {            setZodiacSign("Virgo");        }    } else if (month == 9) {        if (day &gt;= 23) {            setZodiacSign("Scorpio");        } else {            setZodiacSign("Libra");        }    } else if (month == 10) {        if (day &gt;= 22) {            setZodiacSign("Sagittarius");        } else {            setZodiacSign("Scorpio");        }    } else if (month == 11) {        if (day &gt;= 22) {            setZodiacSign("Capricorn");        } else {            setZodiacSign("Sagittarius");        }    }}</code></pre><p style="margin-left:0px;">Just copy paste it in your application and I will explain it step by step.</p><pre><code>const [date, setDate] = useState("1992-08-31");const [zodiacSign, setZodiacSign] = useState(null);</code></pre><p style="margin-left:0px;">We are initialising the date with a certain value. We are using a State hook to calculate the zodiac sign.</p><pre><code>useEffect(() =&gt; {     calculateZodiacSign(date);},[date]); function handleDateInput({ target }) {  setDate(target.value);}</code></pre><p style="margin-left:0px;">As the date changes, we calculate the Zodiac sign by passing the current value of date in the input field.</p><p style="margin-left:0px;">The handleDateInput function is called once the input value changes. It replaces the default value of input with the one currently picked.</p><p style="margin-left:0px;">The function calculateZodiacSign takes in a date and calculates the zodiac sign. The calculated Zodiac sign is shared in a black box image.</p><p style="margin-left:0px;">This is the same svg image code. Be creative, I’d love to see you design something else. Play around with the code.</p><pre><code>{zodiacSign ? (            &lt;svg                xmlns="http://www.w3.org/2000/svg"                preserveAspectRatio="xMinYMin meet"                viewBox="0 0 300 300"                width="400px"                height="400px"            &gt;                &lt;style&gt;{`.base { fill: white; font-family: serif; font-size: 24px;`}&lt;/style&gt;                &lt;rect width="100%" height="100%" fill="black" /&gt;                &lt;text                    x="50%"                    y="50%"                    class="base"                    dominant-baseline="middle"                    text-anchor="middle"                &gt;                    {zodiacSign}                &lt;/text&gt;            &lt;/svg&gt;        ) : null}</code></pre><p style="margin-left:0px;">Awesome. Just refresh your react app and see how it looks like now.</p>

# Adding the Bells and Whistles

Great work on taking the initial steps of building the React app. Now we will move forward and add more code to the `App()` function in the `src/App.js` file. 

## Adding the bells and whistles

Now, we will add some functions, hooks, etc in the function `App()`. Just copy and paste the following code to `function App()` and delete the existing code.

```
const [isWalletInstalled, setIsWalletInstalled] = useState(false);

  // state for whether the app is minting or not.
  const [isMinting, setIsMinting] = useState(false);

  const [NFTContract, setNFTContract] = useState(null);

  const [account, setAccount] = useState(null);

  useEffect(() => {
    if (window.ethereum) {
      setIsWalletInstalled(true);
    }
  }, []);

  function handleDateInput({ target }) {
    setDate(target.value);
  }

  async function connectWallet() {
    window.ethereum
      .request({
        method: "eth_requestAccounts",
      })
      .then((accounts) => {
        setAccount(accounts[0]);
      })
      .catch((error) => {
        alert("Something went wrong");
      });
  }

  useEffect(() => {
    calculateZodiacSign(date);
  }, [date]);

  function calculateZodiacSign(date) {
    let dateObject = new Date(date);
    let day = dateObject.getDate();
    let month = dateObject.getMonth();
    if (month == 0) {
      if (day >= 20) {
        setZodiacSign("Aquarius");
      } else {
        setZodiacSign("Capricorn");
      }
    } else if (month == 1) {
      if (day >= 19) {
        setZodiacSign("Pisces");
      } else {
        setZodiacSign("Aquarius");
      }
    } else if (month == 2) {
      if (day >= 21) {
        setZodiacSign("Aries");
      } else {
        setZodiacSign("Pisces");
      }
    } else if (month == 3) {
      if (day >= 20) {
        setZodiacSign("Taurus");
      } else {
        setZodiacSign("Aries");
      }
    } else if (month == 4) {
      if (day >= 21) {
        setZodiacSign("Gemini");
      } else {
        setZodiacSign("Taurus");
      }
    } else if (month == 5) {
      if (day >= 21) {
        setZodiacSign("Cancer");
      } else {
        setZodiacSign("Gemini");
      }
    } else if (month == 6) {
      if (day >= 23) {
        setZodiacSign("Leo");
      } else {
        setZodiacSign("Cancer");
      }
    } else if (month == 7) {
      if (day >= 23) {
        setZodiacSign("Virgo");
      } else {
        setZodiacSign("Leo");
      }
    } else if (month == 8) {
      if (day >= 23) {
        setZodiacSign("Libra");
      } else {
        setZodiacSign("Virgo");
      }
    } else if (month == 9) {
      if (day >= 23) {
        setZodiacSign("Scorpio");
      } else {
        setZodiacSign("Libra");
      }
    } else if (month == 10) {
      if (day >= 22) {
        setZodiacSign("Sagittarius");
      } else {
        setZodiacSign("Scorpio");
      }
    } else if (month == 11) {
      if (day >= 22) {
        setZodiacSign("Capricorn");
      } else {
        setZodiacSign("Sagittarius");
      }
    }
  }
```

Now, add the following const variables at the top of your `App()` function, where you have added the const variables before.

```
  const [date, setDate] = useState("1992-08-31");
  const [zodiacSign, setZodiacSign] = useState(null);

```

Here, we are initializing the date with a certain value. We will use a State hook to calculate the zodiac sign. Add the following code to the `App()` function.

```
useEffect(() => {
    calculateZodiacSign(date);
  }, [date]);

function handleDateInput({ target }) {
    setDate(target.value);
}

```

- As the date changes, we calculate the Zodiac sign by passing the current value of date in the input field.
- The `handleDateInput` function is called once the input value changes. It replaces the default value of input with the one currently picked.
- The function `calculateZodiacSign` takes in a date and calculates the zodiac sign. The calculated Zodiac sign is shared in a black box image.

We will now add the SVG image code at the end of the `App()` function. Be creative, I’d love to see you design something else. Play around with the code.

```
return (
    <div className="App">
      <h1>Horoscope NFT Minting Dapp</h1>
      <p>Connected as: {account}</p>
 
      <input onChange={handleDateInput} value={date} type="date" id="dob" />
      <br />
      <br />
      {zodiacSign ? (
        <svg
          xmlns="http://www.w3.org/2000/svg"
          preserveAspectRatio="xMinYMin meet"
          viewBox="0 0 300 300"
          width="400px"
          height="400px"
        >
          <style>{`.base { fill: white; font-family: serif; font-size: 24px;`}</style>
          <rect width="100%" height="100%" fill="black" />
          <text
            x="50%"
            y="50%"
            class="base"
            dominant-baseline="middle"
            text-anchor="middle"
          >
            {zodiacSign}
          </text>
        </svg>
      ) : null}
 
      <br />
      <br />
      <button disabled={isMinting} onClick={mintNFT}>
        {isMinting ? "Minting..." : "Mint"}
      </button>
    </div>
  );
```

## That’s a wrap

Awesome Job! If your app is still running, just refresh your React app and see what it looks like now. Otherwise, run the following command:

```
npm start
```

In the next lesson, you will add more code to the `App()` function and connect your front end with the smart contract.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/3.%20%F0%9F%91%91%20Creating%20the%20React%20App/2.%20Adding%20the%20bells%20and%20whistles.md

Adding the bells and whistles

<p style="margin-left:0px;">In order to connect and call the already deployed contract. First, we will be creating a mintNFT function which will be attached to the Mint button showcased on the front end. And, we will figure out a way to create an instance of our currently executed contract to call its functions.</p><p style="margin-left:0px;">Let’s write the functions first.</p><pre><code>useEffect(() =&gt; {    function initNFTContract() {        const provider = new providers.Web3Provider(window.ethereum);        const signer = provider.getSigner();        setNFTContract(new Contract(NFT_CONTRACT_ADDRESS, NFT.abi, signer));    }    initNFTContract();}, [account]); async function mintNFT() {    setIsMinting(true);    try {        await NFTContract.mintNFT(account, zodiacSign);    } catch (e) {    } finally {        setIsMinting(false);    }}</code></pre><p style="margin-left:0px;">The minting function mintNFT simply passes the connected metamask account address and zodiac sign to our contract’s minting function, and while we are minting we disable the mint button to avoid interlocks.</p><p style="margin-left:0px;">In the initNFTContract, we are using a Web3Provider to speak with the blockchain. For that, we need a signer to tell the blockchain that we are a legit person and we are calling the contract.</p><p style="margin-left:0px;">Here we are creating a contract instance by passing our deployed contract address, its abi code and our private key.</p><p style="margin-left:0px;">🚨 While interacting with a smart contract ABI (Application Binary Interface) is one of the essential components. When you compile your NFT smart contract, an ABI low level code is generated. Every time, you make changes to your contract, you should re-compile it. This code has the structure of our contract and becomes a guiding map for us to interact with the deployed contract.</p><p style="margin-left:0px;">When you deployed your contract, your abi was generated in the following path</p><pre><code>artifacts    contracts	    contract-name.sol		    contract-name.dbg.json		    contract-name.json</code></pre><p style="margin-left:0px;"><em><strong>Super important: You will copy this file and replicate in the src folder of your contract, you will create a subfolder abi and will drop this contract-name.json file there.</strong></em></p><p style="margin-left:0px;">Now add the following lines in your App.js file. These lines will go in the start at the import section.</p><pre><code>import  NFT  from  "./abi/horoscopeNFT.json";const  NFT_CONTRACT_ADDRESS = "your_deployed_contract_address";</code></pre><p style="margin-left:0px;">The minting function mintNFT simply passes the connecting account address and zodiac sign to our contract’s minting function, and while we are minting we disable the mint button to avoid interlocks.</p><p style="margin-left:0px;">This is your final app.js code.</p><pre><code>import logo from "./logo.svg";import "./App.css"; import { useEffect, useState } from "react";import { Contract, providers } from "ethers";import NFT from "./abi/horoscopeNFT.json"; const NFT_CONTRACT_ADDRESS = "0xd9DFb8355D1e63fd35196b251Bc5F0c5a849Be38"; function App() {  const [isWalletInstalled, setIsWalletInstalled] = useState(false);  const [date, setDate] = useState("1992-08-31");  const [zodiacSign, setZodiacSign] = useState(null);   // state for whether app is minting or not.  const [isMinting, setIsMinting] = useState(false);   const [NFTContract, setNFTContract] = useState(null);   const [account, setAccount] = useState(null);   useEffect(() =&gt; {    if (window.ethereum) {      setIsWalletInstalled(true);    }  }, []);   function handleDateInput({ target }) {    setDate(target.value);  }   async function connectWallet() {    window.ethereum      .request({        method: "eth_requestAccounts",      })      .then((accounts) =&gt; {        setAccount(accounts[0]);      })      .catch((error) =&gt; {        alert("Something went wrong");      });  }   useEffect(() =&gt; {    calculateZodiacSign(date);  }, [date]);   function handleDateInput({ target }) {    setDate(target.value);  }   function calculateZodiacSign(date) {    let dateObject = new Date(date);    let day = dateObject.getDate();    let month = dateObject.getMonth();    if (month == 0) {      if (day &gt;= 20) {        setZodiacSign("Aquarius");      } else {        setZodiacSign("Capricorn");      }    } else if (month == 1) {      if (day &gt;= 19) {        setZodiacSign("Pisces");      } else {        setZodiacSign("Aquarius");      }    } else if (month == 2) {      if (day &gt;= 21) {        setZodiacSign("Aries");      } else {        setZodiacSign("Pisces");      }    } else if (month == 3) {      if (day &gt;= 20) {        setZodiacSign("Taurus");      } else {        setZodiacSign("Aries");      }    } else if (month == 4) {      if (day &gt;= 21) {        setZodiacSign("Gemini");      } else {        setZodiacSign("Taurus");      }    } else if (month == 5) {      if (day &gt;= 21) {        setZodiacSign("Cancer");      } else {        setZodiacSign("Gemini");      }    } else if (month == 6) {      if (day &gt;= 23) {        setZodiacSign("Leo");      } else {        setZodiacSign("Cancer");      }    } else if (month == 7) {      if (day &gt;= 23) {        setZodiacSign("Virgo");      } else {        setZodiacSign("Leo");      }    } else if (month == 8) {      if (day &gt;= 23) {        setZodiacSign("Libra");      } else {        setZodiacSign("Virgo");      }    } else if (month == 9) {      if (day &gt;= 23) {        setZodiacSign("Scorpio");      } else {        setZodiacSign("Libra");      }    } else if (month == 10) {      if (day &gt;= 22) {        setZodiacSign("Sagittarius");      } else {        setZodiacSign("Scorpio");      }    } else if (month == 11) {      if (day &gt;= 22) {        setZodiacSign("Capricorn");      } else {        setZodiacSign("Sagittarius");      }    }  }   useEffect(() =&gt; {    function initNFTContract() {      const provider = new providers.Web3Provider(window.ethereum);      const signer = provider.getSigner();      setNFTContract(new Contract(NFT_CONTRACT_ADDRESS, NFT.abi, signer));    }    initNFTContract();  }, [account]);   async function mintNFT() {    setIsMinting(true);    try {      await NFTContract.mintNFT(account, zodiacSign);    } catch (e) {    } finally {      setIsMinting(false);    }  }   if (account === null) {    return (      &lt;div className="App"&gt;        {" "}        &lt;br /&gt;        {isWalletInstalled ? (          &lt;button onClick={connectWallet}&gt;Connect Wallet&lt;/button&gt;        ) : (          &lt;p&gt;Install Metamask wallet&lt;/p&gt;        )}      &lt;/div&gt;    );  }  return (    &lt;div className="App"&gt;      &lt;h1&gt;Horoscope NFT Minting Dapp&lt;/h1&gt;      &lt;p&gt;Connected as: {account}&lt;/p&gt;       &lt;input onChange={handleDateInput} value={date} type="date" id="dob" /&gt;      &lt;br /&gt;      &lt;br /&gt;      {zodiacSign ? (        &lt;svg          xmlns="http://www.w3.org/2000/svg"          preserveAspectRatio="xMinYMin meet"          viewBox="0 0 300 300"          width="400px"          height="400px"        &gt;          &lt;style&gt;{`.base { fill: white; font-family: serif; font-size: 24px;`}&lt;/style&gt;          &lt;rect width="100%" height="100%" fill="black" /&gt;          &lt;text            x="50%"            y="50%"            class="base"            dominant-baseline="middle"            text-anchor="middle"          &gt;            {zodiacSign}          &lt;/text&gt;        &lt;/svg&gt;      ) : null}       &lt;br /&gt;      &lt;br /&gt;      &lt;button isLoading={isMinting} onClick={mintNFT}&gt;        Mint      &lt;/button&gt;    &lt;/div&gt;  );}export default App;</code></pre><p style="margin-left:0px;">Refresh your react app.</p><ol><li>Connect your MetaMask Wallet</li><li>Pick your Date of Birth</li><li>Mint your NFT!! 🚀🚀🚀🚀🚀</li></ol><p style="margin-left:0px;">You will get a prompt on metamask to allow minting of NFT in your wallet. Once the nft is minted, you can open <a href="http://testnets.opensea.io/" target="_blank" rel="noopener noreferrer"><u>testnets.opensea.io</u></a> and check in your account.</p><p style="margin-left:0px;">Here is the <a href="https://testnets.opensea.io/assets/0xdad9ab4788d6ffe21ff103290fc6f5f64d76a5bd/2" target="_blank" rel="noopener noreferrer"><u>link to mine.</u></a></p><p style="margin-left:0px;">Massive congrats to you for completing this project. Share your creation with the world and if you liked building with us today. Don’t forget to recommend your friends and family to join our website and learn alongside you.</p><p style="margin-left:0px;">In this project, we have learned so much.<br><br>1. Writing an ERC721 contract &amp; Minting an NFT<br>2. Using Devnet, Testnet<br>3. Connecting MetaMask with your website<br>4. Writing a front-end that interacts with deployed contract.</p><p style="margin-left:0px;">Adios!!</p>

# Connecting With the Smart Contract

Great job on making your front-end. Now, we will move forward and do the last step for our application to run smoothly. We will now connect the front-end with the smart contract we created in the last section.

## Connecting with the smart contract

In order to connect and call the already deployed contract. First, we will be creating a mintNFT function which will be attached to the Mint button showcased on the front end. And, we will figure out a way to create an instance of our currently executed contract to call its functions.

Let’s write the functions first. Add the following code before the return statement in the `App()` function.

```
useEffect(() => {
    function initNFTContract() {
      const provider = new BrowserProvider(window.ethereum);
      provider.getSigner().then((signer) => {
        setNFTContract(new Contract(NFT_CONTRACT_ADDRESS, NFT.abi, signer));
      }).catch((error) => {
        console.error("Error initializing contract:", error);
      });
    }
    initNFTContract();
  }, [account]);
 
  async function mintNFT() {
    setIsMinting(true);
    try {
      const transaction = await NFTContract.mintNFT(account, zodiacSign);
  
      // Wait for the transaction to be confirmed
      await transaction.wait();
  
      // Transaction is confirmed, you can perform any additional actions here if needed
    } catch (e) {
      console.error(e);
    } finally {
      alert("Minting Successful")
      setIsMinting(false);
    }
  }

```

- The minting function `mintNFT` simply passes the connected metamask account address and zodiac sign to our contract’s minting function, and while we are minting we disable the mint button to avoid interlocks.
- In the `initNFTContract`, we are using a `Web3Provider` to speak with the blockchain. For that, we need a signer to tell the blockchain that we are a legitimate person and we are calling the contract.
- Here we are creating a contract instance by passing our deployed contract address, its `abi` code, and our private key.

While interacting with a smart contract ABI (Application Binary Interface) is one of the essential components. When you compile your NFT smart contract, an ABI low-level code is generated. Every time, you make changes to your contract, you should re-compile it. This code has the structure of our contract and becomes a guiding map for us to interact with the deployed contract.

When you deployed your contract, your `abi` was generated in the following path:

`artifacts/contracts/<contract-name.sol>/<contract-name.json>`

Before moving into running the app, we will add the `horoscopeNFT.json` to our project.

1. Create `abi` folder inside of the `src` folder.
2. Create a `horoscopeNFT.json` file inside of an `abi` folder.
3. Paste the code from the `artifacts/contracts/contract-name.json` file present inside of your hardhat project to the `horoscopeNFT.json` file.

Here’s what the file structure will look like.

![Frame 3560339 (8).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/3.%20Creating%20the%20React%20App/3.%20Connecting%20With%20the%20Smart%20Contract/Frame_3560339_(8).webp?raw=true)

Now add the following lines in your `App.js` file. These lines will go in the start at the import section.

```
import  NFT  from  "./abi/horoscopeNFT.json";
const  NFT_CONTRACT_ADDRESS = "your_deployed_contract_address";

```

The minting function `mintNFT` simply passes the connecting account address and zodiac sign to our contract’s minting function, and while we are minting we disable the mint button to avoid interlocks.

## Complete code

This is your final `App.js` code.

```
import "./App.css";
 
import { useEffect, useState } from "react";
import { Contract, BrowserProvider } from "ethers";
import NFT from "./abi/horoscopeNFT.json";
 
const NFT_CONTRACT_ADDRESS = "0x5c512A1eaF19a7A55909F6749345152f58B46d17";
 
function App() {
  const [isWalletInstalled, setIsWalletInstalled] = useState(false);
  const [date, setDate] = useState("1992-08-31");
  const [zodiacSign, setZodiacSign] = useState(null);
 
  // state for whether the app is minting or not.
  const [isMinting, setIsMinting] = useState(false);
 
  const [NFTContract, setNFTContract] = useState(null);
 
  const [account, setAccount] = useState(null);
 
  useEffect(() => {
    if (window.ethereum) {
      setIsWalletInstalled(true);
    }
  }, []);
 
  function handleDateInput({ target }) {
    setDate(target.value);
  }
 
  async function connectWallet() {
    window.ethereum
      .request({
        method: "eth_requestAccounts",
      })
      .then((accounts) => {
        setAccount(accounts[0]);
      })
      .catch((error) => {
        alert("Something went wrong");
      });
  }
 
  useEffect(() => {
    calculateZodiacSign(date);
  }, [date]);
 
 
  function calculateZodiacSign(date) {
    let dateObject = new Date(date);
    let day = dateObject.getDate();
    let month = dateObject.getMonth();
    if (month == 0) {
      if (day >= 20) {
        setZodiacSign("Aquarius");
      } else {
        setZodiacSign("Capricorn");
      }
    } else if (month == 1) {
      if (day >= 19) {
        setZodiacSign("Pisces");
      } else {
        setZodiacSign("Aquarius");
      }
    } else if (month == 2) {
      if (day >= 21) {
        setZodiacSign("Aries");
      } else {
        setZodiacSign("Pisces");
      }
    } else if (month == 3) {
      if (day >= 20) {
        setZodiacSign("Taurus");
      } else {
        setZodiacSign("Aries");
      }
    } else if (month == 4) {
      if (day >= 21) {
        setZodiacSign("Gemini");
      } else {
        setZodiacSign("Taurus");
      }
    } else if (month == 5) {
      if (day >= 21) {
        setZodiacSign("Cancer");
      } else {
        setZodiacSign("Gemini");
      }
    } else if (month == 6) {
      if (day >= 23) {
        setZodiacSign("Leo");
      } else {
        setZodiacSign("Cancer");
      }
    } else if (month == 7) {
      if (day >= 23) {
        setZodiacSign("Virgo");
      } else {
        setZodiacSign("Leo");
      }
    } else if (month == 8) {
      if (day >= 23) {
        setZodiacSign("Libra");
      } else {
        setZodiacSign("Virgo");
      }
    } else if (month == 9) {
      if (day >= 23) {
        setZodiacSign("Scorpio");
      } else {
        setZodiacSign("Libra");
      }
    } else if (month == 10) {
      if (day >= 22) {
        setZodiacSign("Sagittarius");
      } else {
        setZodiacSign("Scorpio");
      }
    } else if (month == 11) {
      if (day >= 22) {
        setZodiacSign("Capricorn");
      } else {
        setZodiacSign("Sagittarius");
      }
    }
  }
 
  useEffect(() => {
    function initNFTContract() {
      const provider = new BrowserProvider(window.ethereum);
      provider.getSigner().then((signer) => {
        setNFTContract(new Contract(NFT_CONTRACT_ADDRESS, NFT.abi, signer));
      }).catch((error) => {
        console.error("Error initializing contract:", error);
      });
    }
    initNFTContract();
  }, [account]);
 
  async function mintNFT() {
    setIsMinting(true);
    try {
      const transaction = await NFTContract.mintNFT(account, zodiacSign);
  
      // Wait for the transaction to be confirmed
      await transaction.wait();
  
      // Transaction is confirmed, you can perform any additional actions here if needed
    } catch (e) {
      console.error(e);
    } finally {
      alert("Minting Successful")
      setIsMinting(false);
    }
  }
  
  if (account === null) {
    return (
      <div className="App">
        {" "}
        <br />
        {isWalletInstalled ? (
          <button onClick={connectWallet}>Connect Wallet</button>
        ) : (
          <p>Install Metamask wallet</p>
        )}
      </div>
    );
  }
  return (
    <div className="App">
      <h1>Horoscope NFT Minting Dapp</h1>
      <p>Connected as: {account}</p>
 
      <input onChange={handleDateInput} value={date} type="date" id="dob" />
      <br />
      <br />
      {zodiacSign ? (
        <svg
          xmlns="http://www.w3.org/2000/svg"
          preserveAspectRatio="xMinYMin meet"
          viewBox="0 0 300 300"
          width="400px"
          height="400px"
        >
          <style>{`.base { fill: white; font-family: serif; font-size: 24px;`}</style>
          <rect width="100%" height="100%" fill="black" />
          <text
            x="50%"
            y="50%"
            class="base"
            dominant-baseline="middle"
            text-anchor="middle"
          >
            {zodiacSign}
          </text>
        </svg>
      ) : null}
 
      <br />
      <br />
      <button disabled={isMinting} onClick={mintNFT}>
        {isMinting ? "Minting..." : "Mint"}
      </button>
    </div>
  );
}
export default App;
```

Note: Don’t forget to update the contract address you got when you deployed the `horoscopeNFT.sol` file.

## Finally, run your app

Refresh your react app if it is already running in your terminal if not then run the `npm start` command and follow the following steps.

1. Connect your MetaMask Wallet
2. Pick your Date of Birth
3. Mint your NFT!! 

You will get a prompt on MetaMask to allow the minting of NFT in your wallet. Once the NFT is minted, you can open  [testnets.opensea.io](http://testnets.opensea.io/)  and check your account.

Here is the [link to mine.](https://testnets.opensea.io/collection/horoscope-nft-12)

![horoscope.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_horoscope/3.%20Creating%20the%20React%20App/3.%20Connecting%20With%20the%20Smart%20Contract/horoscope.webp?raw=true)

## That’s a wrap

Massive congrats to you for completing this project. Share your creation with the world and if you liked building with us today. Don’t forget to recommend your friends and family to join our website and learn alongside you.

In this project, we have learned so much.

1. Writing an ERC721 contract & Minting an NFT
2. Using Devnet, Testnet
3. Connecting MetaMask with your website
4. Writing a front-end that interacts with deployed contracts.


## ⚒️ 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/Create%20a%20Horoscope%20Web3%20NFT%20Application). 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://bit.ly/horo-app-twitter) and [LinkedIn](https://bit.ly/horo-app-linkedin) as well. 🫶

WAGMI!!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Horoscope%20Web3%20NFT%20Application/3.%20%F0%9F%91%91%20Creating%20the%20React%20App/3.%20Connecting%20with%20the%20smart%20contract.md

Connecting with the smart contract

Create a Horoscope Web3 NFT Application

NFTs are not entirely dead. If anything, the NFT market will be worth $231 billion by 2030, as per a 202-pager report published by VMR. And digital artwork is expected to be one of the most sought-after categories. This course is your stepping stone to become a part of that billion dollar NFT industry. Learn to write an NFT smart contract to get started with minting NFTs on OpenSea.

<p>gm everyone 🌈, I am <a href="https://twitter.com/fatimarizwan" target="_blank" rel="noopener noreferrer">Fama</a> and along with Harpal, we are very excited to bring the first ever learning tutorial for developers on MetaSchool.</p><p>So what are we building today? Today we're gonna write a smart contract and mint an image of Elon Musk with the help of that smart contract on blockchain. This project is SO important, because not only will it give you basic understanding of how smart contracts work, but will also help you understand how big collections of NFTs are programmatically minted on different NFT platforms. Cool, right?!</p><h4><strong>Course Overview</strong></h4><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/95dfd6382bb4457db8af1b00a7a11c4f?sharedAppSource=personal_library"><div class="se-component se-video-container __se__float-" contenteditable="false" style="width: 100%;"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/95dfd6382bb4457db8af1b00a7a11c4f" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="95dfd6382bb4457db8af1b00a7a11c4f" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p><p style="margin-left:0px;">We will:</p><ol><li>Cover some super cool tools that you need to interact with as a smart contract developer.</li><li>Understand devnet, testnet and mainnet</li><li>Mint an NFT</li></ol><p style="margin-left:0px;">Please install VScode and node on your machine. Install <a href="https://nodejs.org/en/" target="_blank" rel="noopener noreferrer"><u>node from here</u></a>. Download <a href="https://code.visualstudio.com/" target="_blank" rel="noopener noreferrer"><u>VScode from here</u></a>.</p><p style="margin-left:0px;">If you complete this course with me today, you will be getting a special NFT, a utility token, which will unlock many more opportunities for you on the Metaschool platform. Here is how the NFT looks like.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://lh3.googleusercontent.com/LcZG5dDhsMFkgQ5hXaQosQyBFMVhW5J9rNx30XonmZJway3kX1rmzSet5jEQ4wLynQ-enzHpk-LWdgvS0tP2JrrglCFG1neAiINjOkwT6CNn_Ad-adacqif8Sm4TtaRkBlg0PWRa" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="LcZG5dDhsMFkgQ5hXaQosQyBFMVhW5J9rNx30XonmZJway3kX1rmzSet5jEQ4wLynQ-enzHpk-LWdgvS0tP2JrrglCFG1neAiINjOkwT6CNn_Ad-adacqif8Sm4TtaRkBlg0PWRa" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1600,1094" style="" data-index="0"></figure></div><p style="margin-left:0px;"><br></p><p style="margin-left:0px;">Now before we move forward, let’s set some house rules first.</p><ol><li>Pleaseeeee do your quick assignments properly.</li><li>Join <a href="https://discord.gg/vbVMUwXWgc" target="_blank" rel="noopener noreferrer"><u>our discord server</u></a> and ask all relevant questions there.</li><li>Stay happy and positive!</li></ol><h2 style="margin-left:0px;">🛠 Contributing to this project!</h2><p style="margin-left:0px;">Good news! This is an open source project, you can find the tutorial markdown files <a href="https://github.com/0xmetaschool/Learning-Projects" target="_blank" rel="noopener noreferrer"><u>here</u></a> and the code <a href="https://github.com/0xmetaschool/Mint-Elon-Must-NFT" target="_blank" rel="noopener noreferrer"><u>here</u></a>. If you find an issues in the code or tutorial, please feel free to resolve it.</p><p style="margin-left:0px;">We love love love contributions by our community and we give acknowledgement to contributors in our discord and github profile too.</p><p style="margin-left:0px;">Also, don’t forget to star ⭐️ our repository! we will be very thankful! ♥️</p>

# What are We Building Today?

gm everyone 🌈, we are very excited to bring the first ever learning tutorial for developers on MetaSchool.

So what are we building today? Today we're gonna write a smart contract and mint an image of Elon Musk with the help of that smart contract on blockchain. This project is SO important, because not only will it give you basic understanding of how smart contracts work, but will also help you understand how big collections of NFTs are programmatically minted on different NFT platforms. Cool, right?!

## Course overview

We will:

1. Cover some super cool tools that you need to interact with as a smart contract developer.
2. Understand devnet, testnet and mainnet
3. Mint an NFT

Please install VScode and node on your machine. Install [node from here](https://nodejs.org/en/). Download [VScode from here](https://code.visualstudio.com/).

## Proof of completion

If you complete this course with me, you will be getting XPs and a special NFT which will unlock many more opportunities for you on the Metaschool platform. Here is what the NFT looks like.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L1%20Image%201.webp)

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. We are a free open-source platform and if you follow us on [X](https://bit.ly/elon-nft-twitter) and [LinkedIn](https://bit.ly/elon-nft-linkedin), it would be a great support. 🫣
4. Stay happy and positive!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/1.%20Getting%20Started/1.%20What%20Are%20We%20Building.md

What Are We Building?

<p>Now that we've discussed all that, let’s get straight to development. Most of the Ethereum libraries and tools are built on top of Javascript. This is why I mentioned you need a basic understanding of Javascript.&nbsp;</p><h3>First, install Node.js</h3><p>Node.js is JavaScript runtime built on Chrome's V8 JavaScript engine. I will leave this link <a href="https://hardhat.org/tutorial/setting-up-the-environment.html" target="_blank" rel="noopener noreferrer"><u>here</u></a> to help you install Node.js.&nbsp;</p><p>Blockchain is like a public database and our smart contracts live on that database. This database is publicly available and accessible. Based on our contract's configuration, anyone or only specific people can play around with our contract.&nbsp;Every time we publish a contract on blockchain, it gets an address - a digital footprint 👣 for us to track it. We'll build everything in the 🔷 Ethereum Blockchain and also use Solidity and other libraries for this project.&nbsp;&nbsp;<br><br>Publishing a contract directly on blockchain for learning purposes will be an expensive deal. Every time we create a new contract, edit the contract or publish it on the blockchain, we incur some cost in the form of ETH, or MATIC. In order to avoid that and test the contracts properly, we will create a test environment which pretty much replicates the production environment, is free to use, and easy to access.&nbsp;&nbsp;&nbsp;<br><br>For this purpose, we will use <a href="https://hardhat.org/" target="_blank" rel="noopener noreferrer">HardHat</a>. Hardhat gives you a local Ethereum network designed for rapid development. It allows you to deploy your contracts, run your tests and debug your code without spending a dime. How cool is that? 😊</p><h3>Now install HardHat&nbsp;</h3><ul><li>First make a project directory where you will work and we will install all the dependencies and hardhat there.&nbsp;</li><li>Now open your terminal and run the following commands one by one. Just copy and paste one by one.</li></ul><pre><code>mkdir elonNFTcd elonNFTnpm init --yes npm install --save-dev hardhat</code></pre><p>The above commands means that you created a ‘elonNFT’ folder - an empty one. You entered that folder and initialised the project by making a package.json file. Then you installed hardhat in the same folder.&nbsp;</p><p>If you have followed the instructions properly, and everything went according to the plan, you have HardHat installed. 🎉</p><ul><li>Now write the following command on your terminal:</li></ul><pre><code>npx hardhat</code></pre><p>You will see something like this 👇</p><pre><code>888    888                      888 888               888888    888                      888 888               888888    888                      888 888               8888888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888888    888     "88b 888P"  d88" 888 888 "88b     "88b 888888    888 .d888888 888    888  888 888  888 .d888888 888888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888👷 Welcome to Hardhat v2.11.2 👷‍? What do you want to do? … ❯ Create a JavaScript project  Create a TypeScript project  Create an empty hardhat.config.js  Quit</code></pre><p>We will follow the guide and create a JavaScript project. Something like HelloWorld! Just follow through the questions and answer them yes.&nbsp;</p><p>You will also install some more dependencies; hardhat ether and hardhat waffle in the project. The installation wizard will install those for you. If you haven’t received a prompt for that, run the following command:</p><pre><code>npm install --save-dev @nomicfoundation/hardhat-toolbox</code></pre><p>We will also install a smart contracts library called OpenZeppelin. It will make it easy for us to develop, run and ship smart contracts.&nbsp;</p><pre><code>npm install @openzeppelin/contracts</code></pre><p>And if all that is done, congrats, you have a smart contract ready to go. Yasss!! 🚀 A basic sample project is created for you and you can execute your first ever smart contract.&nbsp;</p><h2>Lesson Video Guide</h2><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/9eea0e22c4744fe3bc44cfd8a52685fb?sharedAppSource=personal_library"><div class="se-component se-video-container __se__float-" contenteditable="false" style="width: 100%;"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/9eea0e22c4744fe3bc44cfd8a52685fb" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="9eea0e22c4744fe3bc44cfd8a52685fb" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p>

# Setting Up the Environment

Now that we've discussed all that, let’s get straight to development. Most of the Ethereum libraries and tools are built on top of Javascript. This is why I mentioned you need a basic understanding of Javascript.

## First, install Node.js

Node.js is JavaScript runtime built on Chrome's V8 JavaScript engine. I will leave this link [here](https://hardhat.org/tutorial/setting-up-the-environment.html) to help you install Node.js.

Blockchain is like a public database and our smart contracts live on that database. This database is publicly available and accessible. Based on our contract's configuration, anyone or only specific people can play around with our contract. Every time we publish a contract on blockchain, it gets an address - a digital footprint 👣 for us to track it. We'll build everything in the Ethereum Blockchain and also use Solidity and other libraries for this project.

Publishing a contract directly on blockchain for learning purposes will be an expensive deal. Every time we create a new contract, edit the contract or publish it on the blockchain, we incur some cost in the form of ETH, or MATIC. In order to avoid that and test the contracts properly, we will create a test environment which pretty much replicates the production environment, is free to use, and easy to access.

For this purpose, we will use [HardHat](https://hardhat.org/). Hardhat gives you a local Ethereum network designed for rapid development. It allows you to deploy your contracts, run your tests and debug your code without spending a dime. How cool is that?

## Now install HardHat

- First make a project directory where you will work and we will install all the dependencies and hardhat there.
- Now open your terminal and run the following commands one by one. Just copy and paste one by one.

```
mkdir elonNFT
cd elonNFT
npm install --save-dev "hardhat@^2.20.0"
```

The above commands means that you created a `elonNFT` folder - an empty one. You entered that folder and installed hardhat in the same folder.

If you have followed the instructions properly, and everything went according to the plan, you have HardHat installed.

- Now write the following command on your terminal:

```
npx hardhat init
```

You will see something like this.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L1%20Image%202.webp) 

We will follow the guide and create a JavaScript project. Something like `HelloWorld!`. Just follow through the questions and answer them yes.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L1%20Image%203.webp) 

You will also install the `hardhat toolbox` dependencies in the project while creating the project. The installation wizard will install it for you. If you haven’t received a prompt for that, run the following command:

```
npm install --save-dev @nomicfoundation/hardhat-toolbox
```

We will also install a smart contracts library called OpenZeppelin. It will make it easy for us to develop, run, and ship smart contracts.

```
npm install @openzeppelin/contracts
```

And if all that is done, congrats, you have a smart contract ready to go. Yasss!! A basic sample project is created for you and you can execute your first-ever smart contract.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/1.%20Getting%20Started/2.%20Setting%20Up%20the%20Environment.md

Setting Up The Environment

<p>Let's go! Write the following code in the terminal and hit enter. Make sure you still are in your project directory in your terminal.</p><pre><code>npx hardhat run scripts/deploy.js</code></pre><p>You will see something like this on your terminal.</p><pre><code>Compiled 1 Solidity file successfullyLock with 1 ETH and unlock timestamp 1695816271 deployed to 0x5FbDB2315678afecb367f032d93F642f64180aa3</code></pre><p>Congratulations ? you've been successful in deploying your first smart contract to your local blockchain environment without having to code a single line. ? When you run the above command, your solidity code is converted into bytecode. A new local blockchain is created and your contract is deployed there. But this blockchain is not permanent, every time you build and run your smart contract, a new blockchain is created in your local environment and the contract is deployed. So it is more like a clean slate - start from scratch. We will get back to it later and figure out a way to deploy our contract permanently. For now, just a piece of information for you to digest.</p><p>Also the above long line of numbers is the address where your contract is deployed. Every contract has its own address. Because of hardhat we were able to create a local blockchain environment just like Ethereum where we can deploy contracts and play around with them free of cost.</p><p>Let's open your project in VSCode or Sublime or any other IDE your prefer. The structure will look something like this.</p><pre><code>elonNFT-&gt; artifacts-&gt; cache-&gt; contracts    -&gt; Lock.sol-&gt; node_modules-&gt; scripts    -&gt; deploy.js-&gt; tests- hardhat.config.js- package-lock.json- package.json</code></pre><p>Let's us open the Lock.sol file and understand the structure of the smart contract. By the way, .sol file stands for solidity.</p><pre><code>/ SPDX-License-Identifier: UNLICENSEDpragma solidity ^0.8.9;// Uncomment this line to use console.log// import "hardhat/console.sol";contract Lock {    uint public unlockTime;    address payable public owner;    event Withdrawal(uint amount, uint when);    constructor(uint _unlockTime) payable {        require(            block.timestamp &lt; _unlockTime,    "Unlock time should be in the future"        );        unlockTime = _unlockTime;        owner = payable(msg.sender);  }    function withdraw() public {    // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal    // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);        require(block.timestamp &gt;= unlockTime,    "You can't withdraw yet");        require(msg.sender == owner,    "You aren't the owner");        emit Withdrawal(address(this).balance, block.timestamp);        owner.transfer(address(this).balance);  }}</code></pre><h2>Understanding the smart contract</h2><p>This code defines a Solidity contract named "Lock". The contract has the following variables:</p><p><em>unlockTime:</em> a public uint (unsigned integer) that stores the time at which the lock can be unlocked.</p><p><em>owner:</em> a public address (an address is a type in Solidity that represents the address of an Ethereum account) that stores the owner of the contract. It is marked "<em>payable</em>" to indicate that the contract can receive Ether (the native cryptocurrency of Ethereum).</p><p>The contract also has an event named "<em>Withdrawal</em>" that can be used to track when someone calls the <em>withdraw()</em> function and gets a payment from the contract.</p><p>The contract has one function, also named "<em>withdraw</em>". This function can be called by anyone, but it has some requirements:</p><ul><li>The caller must be the owner of the contract.</li><li>The current block timestamp must be greater than or equal to the unlockTime.</li></ul><p>If these requirements are met, the function will do the following:</p><ul><li>Emit the "<em>Withdrawal</em>" event, passing in the current balance of the contract and the current block timestamp as arguments.</li><li>Transfer the entire balance of the contract to the owner's account.</li></ul><p>The contract also has a constructor function, which is a special function that is called when the contract is first deployed to the Ethereum network. The constructor takes one argument: <em>unlockTime</em>, which is the desired unlock time for the contract. The constructor does the following:</p><ol><li>It checks that the current block timestamp is less than _unlockTime, and if it is not, it will throw an error with the message "Unlock time should be in the future".</li><li>It sets the value of the unlockTime variable to be equal to _unlockTime.</li><li>It sets the value of the owner variable to be equal to the address of the account that deployed the contract (the msg.sender).</li></ol><p>The pragma statement at the top of the file is used to specify the version of Solidity that the code is written in. The // syntax indicates a single-line comment that is ignored by the compiler.</p><p>Are we good so far? If not join our <a href="https://discord.gg/vbVMUwXWgc">Discord community and go to the #questions channel</a> and share your concerns there.</p><p>Now let’s open the deploy.js in the scripts folder.</p><pre><code>// We require the Hardhat Runtime Environment explicitly here. This is optional// but useful for running the script in a standalone fashion through `node &lt;script&gt;`.//// You can also run a script with `npx hardhat run &lt;script&gt;`. If you do that, Hardhat// will compile your contracts, add the Hardhat Runtime Environment's members to the// global scope, and execute the script.const hre = require("hardhat");async function main() {  const currentTimestampInSeconds = Math.round(Date.now() / 1000);  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;  const lockedAmount = hre.ethers.utils.parseEther("1");  const Lock = await hre.ethers.getContractFactory("Lock");  const lock = await Lock.deploy(unlockTime, { value: lockedAmount });  await lock.deployed();  console.log(    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`  );}// We recommend this pattern to be able to use async/await everywhere// and properly handle errors.main().catch((error) =&gt; {  console.error(error);  process.exitCode = 1;});</code></pre><h3>Understanding Deployment Code</h3><p>The above code is written in JavaScript and is intended to be run using the Hardhat Ethereum development environment. It defines an async function named main() that does the following:</p><ul><li>It calculates the current timestamp in seconds, and stores it in the currentTimestampInSeconds variable.</li><li>It defines a constant named ONE_YEAR_IN_SECS and sets it to the number of seconds in one year.</li><li>It calculates the unlock time for the contract by adding ONE_YEAR_IN_SECS to the currentTimestampInSeconds, and stores the result in the unlockTime variable.</li><li>It defines a constant named lockedAmount and sets it to the value of 1 Ether, using the parseEther method from the ethers.utils library.</li><li>It gets the contract factory for the "Lock" contract, which allows it to deploy new instances of the contract.</li><li>It deploys a new instance of the "Lock" contract, passing in the unlockTime as an argument, and sending lockedAmount worth of Ether along with the deployment transaction.</li><li>It waits for the contract to be fully deployed to the Ethereum network.</li><li>It logs a message to the console with the address of the deployed contract and the calculated unlock time.</li><li>The code then calls the main() function and uses a catch block to handle any errors that may occur.</li></ul><p>The const hre = require("hardhat"); line at the top of the file imports the Hardhat Runtime Environment, which provides a set of tools and libraries for working with Ethereum contracts.</p><p>The const Lock = await hre.ethers.getContractFactory("Lock"); line gets the contract factory for the "Lock" contract, which is a JavaScript object that can be used to deploy new instances of the contract.</p><p>The const lock = await Lock.deploy(unlockTime, { value: lockedAmount }); line uses the contract factory to deploy a new instance of the "Lock" contract, passing in the unlockTime as an argument, and sending lockedAmount worth of Ether along with the deployment transaction. The await lock.deployed(); line waits for the contract deployment to be fully processed by the Ethereum network.</p><p>How about you deploy the contract by uncommenting the console log library, and console messages in the deploy.js file.</p><p>Also, why don't you deploy the contract again with 2 ETH in lock?</p>

# Running Your First Ever Smart Contract

Great job on setting up your HardHat project. Now, we will move forward and learn how we can run the smart contract that exist in the HardHat project.

## Run your first smart contract

Write the following code in the terminal and hit enter. Make sure you still are in your project directory in your terminal.

```
npx hardhat run scripts/deploy.js
```

You will see something like this on your terminal.

```
Compiled 1 Solidity file successfully (evm target: paris).
Lock with 0.001ETH and unlock timestamp 1720701061 deployed to 0x5FbDB2315678afecb367f032d93F642f64180aa3
```

Congratulations! you've been successful in deploying your first smart contract to your local blockchain environment without having to code a single line.

### So, what happened here?

When you run the above command, your solidity code is converted into bytecode. A new local blockchain is created and your contract is deployed there. But this blockchain is not permanent, every time you build and run your smart contract, a new blockchain is created in your local environment and the contract is deployed. So it is more like a clean slate - start from scratch. We will get back to it later and figure out a way to deploy our contract permanently. For now, just a piece of information for you to digest.

```
Lock with 0.001ETH and unlock timestamp 1720701061 deployed to 0x5FbDB2315678afecb367f032d93F642f64180aa3
```

Also, the output line have numbers that is the address where your contract is deployed. Every contract has its own address. Because of hardhat we were able to create a local blockchain environment just like Ethereum where we can deploy contracts and play around with them free of cost.

## Project structure

Let's open your project in VSCode or Sublime or any other IDE your prefer. The structure will look something like this.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L1%20Image%204.webp)

## Lock.sol file

Now, let's us open the `Lock.sol` file and understand the structure of the smart contract. By the way, `.sol` file stands for Solidity.

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

// Uncomment this line to use console.log
// import "hardhat/console.sol";

contract Lock {
    uint public unlockTime;
    address payable public owner;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
    "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
  }

    function withdraw() public {
    // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
    // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime,
    "You can't withdraw yet");
        require(msg.sender == owner,
    "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
  }
}

```

### Understanding the smart contract

This code defines a Solidity contract named `Lock`. The contract has the following variables:

- **`unlockTime`:** a public `uint` (unsigned integer) that stores the time at which the lock can be unlocked.
- `**owner**`_:_ a public address (an address is a type in Solidity that represents the address of an Ethereum account) that stores the owner of the contract. It is marked `payable` to indicate that the contract can receive Ether (the native cryptocurrency of Ethereum).
- The contract also has an event named `Withdrawal` that can be used to track when someone calls the `withdraw()` function and gets a payment from the contract.
- The contract has one function, also named `withdraw`. This function can be called by anyone, but it has some requirements:
  - The caller must be the owner of the contract.
  - The current block timestamp must be greater than or equal to the `unlockTime`.
- If these requirements are met, the function will do the following:
  - Emit the `Withdrawal` event, passing in the current balance of the contract and the current block timestamp as arguments.
  - Transfer the entire balance of the contract to the owner's account.
- The contract also has a constructor function, which is a special function that is called when the contract is first deployed to the Ethereum network.
  - The constructor takes one argument: `unlockTime`, which is the desired unlock time for the contract. The constructor does the following:
    - It checks that the current block timestamp is less than `\_unlockTime`, and if it is not, it will throw an error with the message `"Unlock time should be in the future"`.
    - It sets the value of the `unlockTime` variable to be equal to `\_unlockTime`.
    - It sets the value of the owner variable to be equal to the address of the account that deployed the contract (the msg.sender).
- The pragma statement at the top of the file is used to specify the version of Solidity that the code is written in. The `//` syntax indicates a single-line comment that is ignored by the compiler.

Are we good so far? If not, join our [Discord community and go to the #technical-questions](https://discord.com/channels/924956974628622346/1011880962801541120) channel and share your concerns there.

## Deploy.js file

Now let’s open the `deploy.js` in the scripts folder.

```
// We require the Hardhat Runtime Environment explicitly here. This is optional
// but useful for running the script in a standalone fashion through `node <script>`.
//
// You can also run a script with `npx hardhat run <script>`. If you do that, Hardhat
// will compile your contracts, add the Hardhat Runtime Environment's members to the
// global scope, and execute the script.
const hre = require("hardhat");

async function main() {
  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
  const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
  const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;

  const lockedAmount = hre.ethers.utils.parseEther("1");

  const Lock = await hre.ethers.getContractFactory("Lock");
  const lock = await Lock.deploy(unlockTime, { value: lockedAmount });

  await lock.deployed();

  console.log(
    `Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`
  );
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

```

### Understanding the deployment code

The above code is written in JavaScript and is intended to be run using the Hardhat Ethereum development environment. It defines an async function named `main()` that does the following:

- It calculates the current timestamp in seconds, and stores it in the `currentTimestampInSeconds` variable.
- It defines a constant named `ONE_YEAR_IN_SECS` and sets it to the number of seconds in one year.
- It calculates the unlock time for the contract by adding `ONE_YEAR_IN_SECS` to the `currentTimestampInSeconds`, and stores the result in the unlockTime variable.
- It defines a constant named `lockedAmount` and sets it to the value of 1 Ether, using the `parseEther` method from the `ethers.utils` library.
- It gets the contract factory for the `Lock` contract, which allows it to deploy new instances of the contract.
- It deploys a new instance of the `Lock` contract, passing in the `unlockTime` as an argument, and sending `lockedAmount` worth of Ether along with the deployment transaction.
- It waits for the contract to be fully deployed to the Ethereum network.
- It logs a message to the console with the address of the deployed contract and the calculated unlock time.
- The code then calls the `main()` function and uses a catch block to handle any errors that may occur.
- The `const hre = require("hardhat");` line at the top of the file imports the Hardhat Runtime Environment, which provides a set of tools and libraries for working with Ethereum contracts.
- The `const Lock = await hre.ethers.getContractFactory("Lock");` line gets the contract factory for the `Lock` contract, which is a JavaScript object that can be used to deploy new instances of the contract.
- The `const lock = await Lock.deploy(unlockTime, { value: lockedAmount });` line uses the contract factory to deploy a new instance of the `Lock` contract, passing in the `unlockTime` as an argument, and sending `lockedAmount` worth of Ether along with the deployment transaction. The `await lock.deployed();` line waits for the contract deployment to be fully processed by the Ethereum network.

How about you deploy the contract by uncommenting the console log library, and console messages in the `deploy.js` file.

Also, why don't you deploy the contract again with 2 ETH in lock?


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/1.%20Getting%20Started/3.%20Running%20Your%20First%20Ever%20Smart%20Contract.md

Running Your First Ever Smart Contract

<p>In the contracts folder, create a new file named Elon.sol. This is your new contract file.</p><pre><code>// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.9; //this is the version of the solidity we are using in this contract. import "hardhat/console.sol"; //this is given to us by hardhat to debug our code. It is very helpful in local environment. contract ElonNFT {      constructor() {        console.log("This is my Elon Musk NFT contract!!");    }}</code></pre><p>This code defines a Solidity contract named "ElonNFT". The contract has a constructor function, which is a special function that is called when the contract is first deployed to the Ethereum network.</p><p>The pragma statement at the top of the smart contract specifies the version of Solidity that the code is written in.</p><p>The import statement includes the "console.sol" library, which is provided by the Hardhat Ethereum development environment and allows you to print messages to the console for debugging purposes.</p><p>The constructor function simply logs a message to the console using the console.log function, which was imported from the "console.sol" library. When the contract is deployed, this message will be printed to the console.</p><p>I hope the explanation makes it super simple for you to understand the above code.</p><p>Now let's go to the deployment file.</p><p>First things first, I will rename the deploy.js file to run.js and then I will make some changes to the file. You can go ahead and copy them.</p><pre><code>const hre = require("hardhat"); async function main() {  // We get the contract to deploy  const ElonNFT = await hre.ethers.getContractFactory("ElonNFT");  const elon = await ElonNFT.deploy();   await elon.deployed();   console.log("ElonNFT deployed to:", elon.address);} // We recommend this pattern to be able to use async/await everywhere// and properly handle errors.main()  .then(() =&gt; process.exit(0))  .catch((error) =&gt; {    console.error(error);    process.exit(1);  });</code></pre><p>The above code is almost same as our Lock contract related script. But I have made some changes. Now I am calling the const to store our contract as ElonNFT which is our contract name and then deploying it using the terminal.</p><p>It defines an async function named main() that does the following:</p><ul><li>It gets the contract factory for the "ElonNFT" contract, which allows it to deploy new instances of the contract.</li><li>It deploys a new instance of the "ElonNFT" contract.</li><li>It waits for the contract to be fully deployed to the Ethereum network.</li><li>It logs a message to the console with the address of the deployed contract.</li></ul><p>The code then calls the main() function and uses a catch block to handle any errors that may occur. It also uses the then function to specify that the process should exit with a code of 0 (success) after the main() function completes. If an error occurs, the process will exit with a code of 1 (failure).</p><p>Now let's run the following code in your terminal.</p><pre><code>npx hardhat run scripts/run.js</code></pre><p>Once the contract is deployed, we will see the constructor message on screen and the address where the contract is deployed to.</p><pre><code>Compiled 1 Solidity files successfullyThis is my Elon Musk NFT contract!!ElonNFT deployed to: 0x5FbDB2315678afecb367f032d93F642f64180aa3</code></pre><p>🎉BOOOOMM!! Your first NFT contract is deployed. Give yourself a pat on the back.</p>

# Creating an Elon Musk NFT Locally

Welcome back! Great work on learning all about the HardHat project and the files it creates by default. Now, we will move forward and add files to our HardHat project.

## Create `ElonNFT` contract

In the `contracts` folder, create a new file named `Elon.sol`. This is your new contract file.

```
// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.9; //this is the version of the solidity we are using in this contract.

import "hardhat/console.sol"; //this is given to us by hardhat to debug our code. It is very helpful in local environment.

contract ElonNFT {
    constructor() {
        console.log("This is my Elon Musk NFT contract!!");
    }
}
```

### Understanding the code

This code defines a Solidity contract named "ElonNFT".

- The contract has a `constructor` function, which is a special function that is called when the contract is first deployed to the Ethereum network.
- The pragma statement at the top of the smart contract specifies the version of Solidity that the code is written in.
- The import statement includes the `console.sol` library, which is provided by the Hardhat Ethereum development environment and allows you to print messages to the console for debugging purposes.
- The constructor function simply logs a message to the console using the `console.log` function, which was imported from the `console.sol` library. When the contract is deployed, this message will be printed to the console.

I hope the explanation makes it super simple for you to understand the above code.

Now let's go to the deployment file.

## Deployment file

First things first, I will rename the `deploy.js` file to `run.js` and then I will make some changes to the file. You can go ahead and copy them.

```
const hre = require("hardhat");

async function main() {
  console.log("Deploying Contract...");
  const elon = await hre.ethers.deployContract("ElonNFT");
  console.log("Contract deployed to address:", elon.target);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

### Understanding the code

The above code is almost same as our `Lock` contract related script. But I have made some changes. Now I am calling the const to store our contract as `ElonNFT` which is our contract name and then deploying it using the terminal.

It defines an async function named `main()` that does the following:

- It gets the contract factory for the `ElonNFT` contract, which allows it to deploy new instances of the contract.
- It deploys a new instance of the `ElonNFT` contract.
- It waits for the contract to be fully deployed to the Ethereum network.
- It logs a message to the console with the address of the deployed contract.

The code then calls the `main()` function and uses a catch block to handle any errors that may occur. It also uses the then function to specify that the process should exit with a code of `0` (success) after the `main()` function completes. If an error occurs, the process will exit with a code of `1` (failure).

## Run deployment

First, run the following command to compile the smart contract

```
npx hardhat compile
```

You’ll get the the output something like this.

```
Compiled 2 Solidity files successfully (evm target: paris).
```

Now, run the script file using the following command.

```
npx hardhat run scripts/run.js
```

Once the contract is deployed, we will see the constructor message on screen and the address where the contract is deployed to.

```
Deploying Contract...
This is my Elon Musk NFT contract!!
Contract deployed to address: 0x5FbDB2315678afecb367f032d93F642f64180aa3
```

BOOOOMM!! Your first NFT contract is deployed. Give yourself a pat on the back.

Next, we will write the minting script for our NFT contract.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/2.%20Hello%20World%20NFT/1.%20Creating%20an%20Elon%20Musk%20NFT%20Locally.md

Creating an Elon Musk NFT Locally

<p>So far you have a basic understanding of a smart contract and you have already deployed one too.</p><h3>Now, let’s get to minting an NFT for you. 😋</h3><p>We will write a detailed NFT contract and for that we will use <a href="https://openzeppelin.com/">OpenZeppelin</a>. Remember you installed it while setting up your workspace.</p><p>OpenZeppelin is a reusable and secure smart contracts library, which means that you can import this library, inherit the contracts in your project and get started without having to worry about security issues and reinventing the wheel. I’d recommend you to check out their official website, read stuff and get to know more.</p><p>For minting NFTs, we will create a basic contract based on ERC721 - the non-fungible token standard. OpenZeppelin gives us the base ERC721 with all the important functionalities. You can read more about this contract and all functions encapsulated in that contract <a href="https://docs.openzeppelin.com/contracts/4.x/erc721">here</a>. And while you are at it, read all the functions and capabilities that come packaged in this magical library <a href="https://docs.openzeppelin.com/contracts/4.x/api/token/erc721">here</a>.</p><p>Since we had already created the Elon.sol file. We will just update it. Don't worry if you don't get anything. Just copy-paste it and I will explain it step by step.</p><pre><code>// SPDX-License-Identifier: UNLICENSEDpragma solidity ^0.8.9;import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";import "@openzeppelin/contracts/utils/Counters.sol";import "hardhat/console.sol";contract ElonNFT is ERC721URIStorage {    using Counters for Counters.Counter;    Counters.Counter private _tokenIds;    constructor() ERC721("ElonMusk", "ELON") {}    function mintNFT() public returns (uint256) {        _tokenIds.increment();        uint256 newItemId = _tokenIds.current();        _mint(msg.sender, newItemId);        _setTokenURI(newItemId, "Hello World");        console.log(            "The NFT ID %s has been minted to %s",            newItemId,            msg.sender        );        return newItemId;    }}</code></pre><p>Now let me explain the code step by step ?</p><p>This code defines a contract called "ElonNFT" which is an implementation of the ERC721 standard for non-fungible tokens (NFTs).</p><p>The contract imports and uses several other contracts:</p><ul><li>The ERC721URIStorage contract provides functionality for storing and retrieving the URI (uniform resource identifier) of an NFT.</li><li>The Counters contract provides a utility for generating unique sequential token IDs.</li><li>The console contract provides an interface for logging messages to the console.</li></ul><p>The ElonNFT contract has a single public function called mintNFT, which does the following:</p><ul><li>Increments the token ID counter by calling the increment function from the Counters contract.</li><li>Retrieves the current value of the token ID counter by calling the current function from the Counters contract.</li><li>Calls the _mint function inherited from the ERC721 contract to mint a new NFT and assign it the newly generated token ID.</li><li>Calls the _setTokenURI function inherited from the ERC721URIStorage contract to set the URI of the newly minted NFT to "Hello World".</li><li>Calls the console.log function to log a message to the console indicating that the NFT has been minted and the ID of the NFT.</li><li>Returns the ID of the newly minted NFT.</li></ul><p>Now let's take a look at our script file and see how do we deploy this project and call this function.</p><pre><code>const hre = require("hardhat"); async function main() {  // We get the contract to deploy  const ElonNFT = await hre.ethers.getContractFactory("ElonNFT");  const elon = await ElonNFT.deploy();   await elon.deployed();  console.log("ElonNFT deployed to:", elon.address);   let txn = await elon.mintNFT();  await txn.wait(); } // We recommend this pattern to be able to use async/await everywhere// and properly handle errors.main()  .then(() =&gt; process.exit(0))  .catch((error) =&gt; {    console.error(error);    process.exit(1);  });</code></pre><p>The above code demonstrates how to deploy an instance of the ElonNFT contract and mint a new NFT using the mintNFT function.</p><p>The code begins by importing the hardhat module and defining an async function called main. This function will contain the code that is executed when the script is run.</p><p>Inside the main function, the following occurs:</p><ul><li>The contract factory for the ElonNFT contract is retrieved using the getContractFactory function from the hardhat.ethers module.</li><li>A new instance of the ElonNFT contract is deployed using the contract factory and stored in the elon variable.</li><li>The deployed function is called on the elon contract instance to wait until the contract is deployed to the blockchain.</li><li>A message is logged to the console indicating the address of the deployed contract.</li><li>The mintNFT function is called on the elon contract instance to mint a new NFT.</li><li>The wait function is called on the returned transaction object to wait until the transaction is mined and the NFT is minted.</li><li>Finally, the main function is executed by calling it and passing the resolved value to the then function of the returned promise. If an error occurs, it is caught and logged to the console.</li></ul><p>When you run the script <code>npx hardhat run scripts/run.js</code>, you will see something like this ?</p><pre><code>The NFT ID 1 has been minted to 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266</code></pre><p>And there weeee gooo! Congratulations, using OpenZeppelin ERC721 contract, you successfully created a contract, deployed it on blockchain and then called a function of that contract too. You should be proud of yourself.</p><p>Now you must be wondering, ‘Fatima! I have been doing everything on my console, when can I see my ElonMusk NFT deployed on real blockchain?’</p><p><strong>Well, we're moving to that just now. Gear up!</strong></p><p>Btw, if you have any questions, please share in the questions <a href="https://discord.gg/vbVMUwXWgc">channel in our discord.</a></p>

# Minting an NFT

So far, you have a basic understanding of a smart contract and you have already deployed one too. Now, you will write the minting script for your NFT.

We will write a detailed NFT contract and for that we will use [OpenZeppelin](https://openzeppelin.com/). Remember you installed it while setting up your workspace.

## OpenZeppelin library

OpenZeppelin is a reusable and secure smart contracts library, which means that you can import this library, inherit the contracts in your project and get started without having to worry about security issues and reinventing the wheel. I’d recommend you to check out their official website, read stuff and get to know more.

## Minting your NFT

For minting NFTs, we will create a basic contract based on ERC721 - the non-fungible token standard. OpenZeppelin gives us the base ERC721 with all the important functionalities. You can read more about this contract and all functions encapsulated in that contract [here](https://docs.openzeppelin.com/contracts/4.x/erc721). And while you are at it, read all the functions and capabilities that come packaged in this magical library [here](https://docs.openzeppelin.com/contracts/4.x/api/token/erc721).

### Write code

Since we had already created the `Elon.sol` file. We will just update it. Don't worry if you don't get anything. Just copy-paste it and I will explain it step by step.

```
// SPDX-License-Identifier: UNLICENSED

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "hardhat/console.sol";

contract ElonNFT is ERC721URIStorage {

    //Counters.Counter private _tokenIds -- replaced with below
    uint private _tokenIds;

    constructor() ERC721("ElonMusk", "ELON") {}

    function mintNFT() public returns (uint256) {
        // _tokenIds.increment() -- replaced with below
        _tokenIds++;
        //uint256 newItemId = _tokenIds.current(); -- replaced with below
        uint newItemId = _tokenIds;
        _mint(msg.sender, newItemId);
        _setTokenURI(newItemId, "hello world");
        console.log(
            "The NFT ID %s has been minted to %s",
            newItemId,
            msg.sender
        );
        return newItemId;
    }
}
```

Now let me explain the code step by step?

### Understanding the code

This code defines a contract called `ElonNFT` which is an implementation of the ERC721 standard for non-fungible tokens (NFTs).

The contract imports and uses several other contracts:

- The `ERC721URIStorage` contract provides functionality for storing and retrieving the URI (uniform resource identifier) of an NFT.
- The Counters contract provides a utility for generating unique sequential token IDs.
- The console contract provides an interface for logging messages to the console.

The ElonNFT contract has a single public function called `mintNFT`, which does the following:

- Increments the token ID counter by calling the increment function from the Counters contract.
- Retrieves the current value of the token ID counter by calling the current function from the Counters contract.
- Calls the `_mint` function inherited from the ERC721 contract to mint a new NFT and assign it the newly generated token ID.
- Calls the `_setTokenURI` function inherited from the `ERC721URIStorage` contract to set the URI of the newly minted NFT to `"Hello World"`.
- Calls the `console.log()` function to log a message to the console indicating that the NFT has been minted and the ID of the NFT.
- Returns the ID of the newly minted NFT.

## Update deployment script

Now let's take a look at our script file and see how do we deploy this project and call this function.

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

async function main(){

  const deployNFTContract = await ethers.deployContract("ElonNFT");

  const elon = await deployNFTContract.waitForDeployment();

  console.log("Elon contract address is:", await elon.getAddress());

  console.log("Minting NFT...");
  let txn = await elon.mintNFT();
  await txn.wait();
  console.log("Yayy.. NFT minted successfully!!!");
}

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

### Updating `hardhat.config.js`

So you might have noticed we are using solidity `^0.8.20` in Elon.sol, so we need to update `hardhat.config.js` accordingly to make sure the files compile successfully, so let's update the config like this:

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

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.24",
};
```

### Understanding the code

The above code demonstrates how to deploy an instance of the ElonNFT contract and mint a new NFT using the mintNFT function.

The code begins by importing the hardhat module and defining an async function called main. This function will contain the code that is executed when the script is run.

Inside the main function, the following occurs:

- The contract factory for the ElonNFT contract is retrieved using the getContractFactory function from the hardhat.ethers module.
- A new instance of the ElonNFT contract is deployed using the contract factory and stored in the elon variable.
- The deployed function is called on the elon contract instance to wait until the contract is deployed to the blockchain.
- A message is logged to the console indicating the address of the deployed contract.
- The mintNFT function is called on the elon contract instance to mint a new NFT.
- The wait function is called on the returned transaction object to wait until the transaction is mined and the NFT is minted.
- Finally, the main function is executed by calling it and passing the resolved value to the then function of the returned promise. If an error occurs, it is caught and logged to the console.

## Run your script

When you run the script `npx hardhat run scripts/run.js`, you will see something like this.

```
Compiled 16 Solidity files successfully (evm target: paris).
Elon contract address is: 0x5FbDB2315678afecb367f032d93F642f64180aa3
Minting NFT...
The NFT ID 1 has been minted to 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
Yayy.. NFT minted successfully!!!
```

And there weeee gooo! Congratulations, using OpenZeppelin ERC721 contract, you successfully created a contract, deployed it on blockchain and then called a function of that contract too. You should be proud of yourself.

Now you must be wondering, “I have been doing everything on my console, when can I see my ElonMusk NFT deployed on real blockchain?”

**Well, we're moving to that just now. Gear up!**

Btw, if you have any questions, please share in the questions [channel in our discord.](https://discord.gg/vbVMUwXWgc)


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/2.%20Hello%20World%20NFT/2.%20Minting%20an%20NFT.md

Minting an NFT

<p>Every NFT has some data linked to it in the form of JSON format that describes the NFT. We call it metadata. This metadata has a special JSON format and the format needs to be followed if we want our NFT to appear properly on platforms like OpenSea, Rarible, etc.&nbsp;</p><p>In the previous lesson, I shared how we wrote ‘Hello World’ instead of sharing the Uniform Resource Identifier, I mean, the data about the NFT. 😅</p><p>Let's look back at it 👀</p><pre><code>_setTokenURI(newItemId, "Hello World");</code></pre><p>Now we will use the standard format required by NFT platforms to describe the data related to the NFT.&nbsp;</p><pre><code>{		"name":"Elon Musk",	"description":"Making inter planetory travel possible and pushing the boundaries for mankind.",	"image":"https://64.media.tumblr.com/242f308aee595552a0898e11b4bfb9a3/tumblr_pe1d49XUHB1tsqz3b_1280.jpg",		"attributes":	[		{			"trait_type":"Zodiac","value":"Cancer"		},		{			"trait_type":"Height","value":"6'1"		},		{	"trait_type":"Personality Type","value":"INTJ"		}	]}</code></pre><p>I will use the <a href="https://jsonkeeper.com" target="_blank" rel="noopener noreferrer">jsonkeeper</a> website to convert my JSON into linkable URL. Here is the url: <a href="https://jsonkeeper.com/b/JJJS" target="_blank" rel="noopener noreferrer">https://jsonkeeper.com/b/JJJS</a></p><p>💁‍♀️ I will recommend you to keep your image hosted somewhere safe, the image can't be altered and it doesn't incur you costs. I am being lazy here and found a website where an image was already hosted. Please never do this for your real NFTs. If your server is down or compromised, the NFT will lose its value and important data.&nbsp;</p><p><em><strong>As NFTschool describes it,</strong></em></p><p>"When an NFT is created and linked to a digital file that lives on some other system, <em>how</em> the data is linked is critical. There are a few reasons why traditional HTTP links aren't a great fit for the demands of NFTs.</p><p>With an HTTP address like https://cloud-bucket.provider.com/my-nft.jpg, anyone can fetch the contents of my-nft.jpg, as long as the owner of the server pays their bills. However, there's no way to guarantee that the contents of my-nft.jpg are the same as they were when the NFT was created. The server owner can easily replace my-nft.jpg with something different at any time, causing the NFT to change its meaning.</p><p>This problem was demonstrated by an artist who <a href="https://cointelegraph.com/news/opensea-collector-pulls-the-rug-on-nfts-to-highlight-arbitrary-value" target="_blank" rel="noopener noreferrer">pulled the rug (opens new window)</a> on NFTs he created by changing their images after they were minted and sold to others."</p><p>Coming back, we will pass on the JSON metadata url and deploy our contract.</p><pre><code>_setTokenURI(newItemId, "https://jsonkeeper.com/b/JJJS");</code></pre><p>Let's deploy our contract now. You will see this output.</p><pre><code>Compiled 1 Solidity file successfullyThe NFT ID 1 has been minted to 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266</code></pre><p>We are reaching the very last part of this project where we will deploy this contract to testnet and then production as well.</p><p>Are you excited? I am very excited!!!!!!!!!</p><h2>Lesson Video</h2><p></p><figure class="media"><div data-oembed-url="https://www.loom.com/share/98a7fe23dfee4de7a7f00459af250b2e?sharedAppSource=personal_library"><div class="se-component se-video-container __se__float-" contenteditable="false" style="width: 100%;"><figure style="width: 100%; height: 100%; padding-bottom: 100%; margin: 0px;"><iframe src="https://www.loom.com/embed/98a7fe23dfee4de7a7f00459af250b2e" data-percentage="100%,100%" data-size="100%,100%" data-align="" data-file-name="98a7fe23dfee4de7a7f00459af250b2e" data-file-size="0" data-origin="100%,100%" style="position: absolute; width: 100%; height: 100%; top: 0; left: 0;" data-index="0"></iframe></figure></div><div style="position: relative; padding-bottom: 100%; height: 0; "><br></div></div></figure><p></p>

# Adding Image to NFT

So, you’ve learned how to create, deploy, and mint your token locally. Now, let’s move forward and give a visual look to our NFT.

Every NFT has some data linked to it in the form of JSON format that describes the NFT. We call it metadata. This metadata has a special JSON format and the format needs to be followed if we want our NFT to appear properly on platforms like OpenSea, Rarible, etc.

In the previous lesson, I shared how we wrote ‘Hello World’ instead of sharing the Uniform Resource Identifier, I mean, the data about the NFT.

Let's look back at it.

```
_setTokenURI(newItemId, "Hello World");
```

Now we will use the standard format required by NFT platforms to describe the data related to the NFT.

## Get started with Pinata IPFS

First of all, we will upload our chosen image to Pinata. You can choose any image you want to choose but we need to follow a certain method to make a normal image to an NFT.

So what is Pinata? It works like a peer-to-peer database storage system. Here, we save our data and access it using a URL. So, here’s what we’re gonna do.

1. Signup to Pinata
2. Upload an image to Pinata
3. Fetch the image URL
4. Add image URL to JSON file and create metadata
5. Upload metadata JSON file to IPFS

So, I have given you an overview here. Let’s move onto actually doing it.

### Signup to Pinata

Head over to [Pinata](https://www.pinata.cloud/) and create a free account.

1. Click on the “Start Building” button. It will take you to the signup page.
2. Enter your email address, select “Builder” in the title section, and move “Next.”
3. Set your first name, last name and password.
4. Confirm your email by entering the confirmation code.
5. Your Pinata profile is ready to go. Here’s what it will look like:

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L2%20Image%201.webp)

### Upload an image to Pinata

Next, you need to upload an image file to the Pinata dashboard.

1. Click on the “+ Add Files” button and select “File”.
2. Click on the “Select a file” button, browse through your folder, find the image you want to upload, and select it.

I am downloading the image from Google. You can download any other image. Here’s how I’m doing it:

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L2%20Image%202.webp)

### Fetch the image URL

Now that you have uploaded the image to Pinata. You need to fetch the URL.

1. Click on the uploaded image's file name on pinata which will open the image in a new tab.
2. Copy the URL of the image.

### Add image URL to JSON file and create metadata

Now, create a new file named `Elon_musk.json` file wherever you want. I created the file outside of my HardHat project. Paste the following code and update the image URL with your image URL.

```
{
	"name":"Elon Musk",
	"description":"Making inter planetory travel possible and pushing the boundaries for mankind.",
	"image":"YOUR-IMAGE-PINATA-URL",

	"attributes":
	[
		{
			"trait_type":"Zodiac","value":"Cancer"
		},
		{
			"trait_type":"Height","value":"6'1"
		},
		{	"trait_type":"Personality Type","value":"INTJ"
		}
	]
}

```

### Upload metadata JSON file to IPFS

Now that you have created the JSON file, follow the following step.

1. Upload the JSON file to Pinata.
2. Copy the Pinata JSON public link from the “Share” button.

You’re done with Pinata. Now, we need to update the link in `Elon.sol` file. Let’s do that.

## Update `Elon.sol` file

Coming back, we will pass on the JSON metadata url and deploy our contract. Remember to update this in `Elon.sol` file.

```
_setTokenURI(newItemId, "YOUR-JSON-FILE-LINK-FROM-PINATA");
```

Let's deploy our contract using `npx hardhat run scripts/run.js` command. You will see this output.

```
Compiled 1 Solidity file successfully
Deploying Contract...
Contract deployed to address: 0x5FbDB2315678afecb367f032d93F642f64180aa3
Minting NFT...
The NFT ID 1 has been minted to 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266
```

We are reaching the very last part of this project where we will deploy this contract to testnet and then production as well.

Are you excited? I am very excited!!!!!!!!!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/2.%20Hello%20World%20NFT/3.%20Adding%20Image%20to%20NFT.md

Adding Image to NFT

<p>As NFTschool, describes it.</p><p>"There are three environments for a blockchain network: mainnet, devnet, and testnet.</p><h3><strong>Devnet</strong></h3><p>Till now we were using the local development network to run our smart contracts. This is the easiest and fastest way to get started, iterate and run things without having to setup tons of stuff. For setting up devnet, we used Hardhat that provided us a local Ethereum like blockchain environment. Remember at the start of this project, I mentioned, how every time we deploy a smart contract it is a start from scratch. Now we are being promoted. Since we have setup a basic contract which we believe can run. We will use a testnet environment.</p><h3><strong>Testnet</strong></h3><p>Because devnets are a simplified simulation of the real network, they don't always behave in quite the same way. This is a good thing when you want fast development cycles, but not so great when you want to know how your contract will actually work on mainnet.</p><p>For that, you can deploy and run your contract on a test network, or <em>testnet</em>. These networks generally run the same code as the mainnet, but they have separate blockchain states and may be configured differently in various ways.</p><h3><strong>Mainnet</strong></h3><p>The <em>mainnet</em> is the official production network. It is considered the source of truth, and its tokens can be exchanged for "real world" money in various ways. As you might imagine, using the mainnet for development and testing is an expensive proposition."</p><h3><strong>Setting up the testnet environment</strong></h3><p>We will do the following things.</p><ul><li>Add Goerli network to Metamask</li><li>Get some fake ETH for the transaction</li><li>Create a Goerli Network on Quick Node</li><li>Update our hardhat.config.js file to include the Goerli network.</li></ul><h3><strong>Changing your network on MetaMask</strong></h3><p>We will not be using the live/production environment at the moment because it will be expensive to deploy a contract. You will need some real ETH to do that! And of course, learning and deploying contracts on production for the purpose of learning is not sustainable.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/36a5e24eba1b8eba416b52b8693afbe0a9b7eabcd6cfae5d9c4f64d83842d00e/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f465778515846536a784d79656173563078764b5a66516a57576831506867366e4c4f72393576694b2e706e67" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f465778515846536a784d79656173563078764b5a66516a57576831506867366e4c4f72393576694b2e706e67" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="2239,1531" style="" data-index="0"></figure></div><p>We will switch to Goerli Network, it is a test network which pretty much is a simulation of Ethereum blockchain production. Just open chrome and switch your network to Goerli, if you are not able to see it.</p><p>Here are the steps to turn on test networks</p><ol><li>Go to settings</li><li>Open Advanced</li><li>Scroll down to Show Test Networks</li><li>Turn on</li></ol><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/529780ea7f82fdf6824fe8d71b53ac4f96780a54e2d18a950e79c7d15f100f7c/68747470733a2f2f6c68332e676f6f676c6575736572636f6e74656e742e636f6d2f4a31614139765a636638674533683979704e49326e51302d775279706e434343774e42444874633743397163797a6c6b624f6d6c623649445578784e31784977517066497753505a726d58792d4335685336356c6346494b673555304c5a61586847775f793251784775726d68775a5348634a774b30676b354b43615570753435706d7a386a6c32" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f6c68332e676f6f676c6575736572636f6e74656e742e636f6d2f4a31614139765a636638674533683979704e49326e51302d775279706e434343774e42444874633743397163797a6c6b624f6d6c623649445578784e31784977517066497753505a726d58792d4335685336356c6346494b673555304c5a61586847775f793251784775726d68775a5348634a774b30676b354b43615570753435706d7a386a6c32" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1089,607" style="" data-index="1"></figure></div><h4>&nbsp;</h4><h3><strong>Get some fake ETH $$ 🤑</strong></h3><p>Try the following website and try to get some fake ETHs. 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 ETH.</p><p>All you have to do is to drop your public address on the following links and the ETH will be transferred.</p><ol><li><a href="https://www.goerlifaucet.com/" target="_blank" rel="noopener noreferrer">https://www.goerlifaucet.com/</a></li></ol><h3><strong>Get your private 🦊 MetaMask key</strong></h3><p>Now let's get open our Metamask wallet and take out the private it. If you don't know how to use Metamask, first take this 5 mins guide on ⚡ <a href="https://metaschool.so/courses/understand-and-setup-metamask-account" target="_blank" rel="noopener noreferrer">Setting up your Metamask wallet</a>.</p><p>Open the Metamask extension to find your private 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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history.</p><p>Follow the image below to get your Private Key.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/18a2dc5674c9450c4ac0c9e2b26d1af0cbb77579cf50e965d49f1083d15c387d/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f785239306f44466777464c674f494e303361496c71466845707855684637523073533961424643522e706e67" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f785239306f44466777464c674f494e303361496c71466845707855684637523073533961424643522e706e67" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="2239,1531" style="" data-index="2"></figure></div><p>I will tell you how to keep your account and private key safe in the next steps. For now, export private it and paste it somewhere secure.&nbsp;</p><p>🚨DON'T COMMIT IT ON GITHUB, DONT SHARE IT ON DISCORD, DON'T SHARE IT ANYWHERE! IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUND AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.</p><p>BE EXTRAAA VIGILANT!!</p><h3><strong>Creating Quick Node ⛓ endpoint</strong></h3><p>Now, we need to set up <a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer">QuickNode</a> with Ethereum testnet nodes, it’s gonna take like 5 mins.</p><p>QuickNode is a platform which helps you access the blockchain environment without going through the hassle of hosting your own node, saving time and resources. This platform lets you access blockchain nodes in a few clicks and you can scale the node performance according to your need thus creating an environment for you to scale your DApp.</p><ul><li><a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner" target="_blank" rel="noopener noreferrer">Sign in / Sign up to your QuickNode account</a></li><li>Click on create an QuickNode endpoint</li></ul><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/16be74f40874b3818e99a9eafbd3bdc0943b512a7ab7374e732ce4522dc4787f/68747470733a2f2f692e696d6775722e636f6d2f667458384146622e706e67" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f692e696d6775722e636f6d2f667458384146622e706e67" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="1600,900" style="" data-index="3"></figure></div><p>Now select Ethereum as Network and Goerli as chain and continue. We don’t need any add-on so click create endpoint now. Your endpoint HTTP address is important, save it somewhere for now, and we will use it in our project later.</p><h3><strong>🌈 Getting Ready for Deployment</strong></h3><p>First let’s do some basic housekeeping stuff. We know that there are massive scams and security issues happening in the crypto world. You make a mistake and it can cost you a life time.</p><p>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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.</p><p><code>npm install dotenv --save touch .gitignore</code></p><p>Now go ahead and create .env file at the base of your project. Open your .gitignore file and write .env there.</p><p>All the secrets and important keys related to your project will be stored in .env file and we can access this data whenever and wherever. In the gitignore file we simply write .env, it tells git to ignore that file from future commits.</p><p>Open the .env file you have just created. Add your Metamask Private Key and Alchemy App HTTP URL there. Should be something like this.</p><pre><code>PRIVATE_KEY = YOUR_PRIVATE_KEYAPI_URL_KEY = YOUR_QUICKNODE_APP_URL</code></pre><p>We will update our hardhat config file to setup Goerli Deployment.</p><h3><strong>Updating Hardhat Config file</strong></h3><p>Open your hardhat.config.js file and paste the following code.</p><pre><code>/** * @type import('hardhat/config').HardhatUserConfig */require('dotenv').config(); //all the key value pairs are being made available due to this librequire("@nomicfoundation/hardhat-toolbox"); const {API_URL_KEY, PRIVATE_KEY} = process.env; //environment variables are being loaded here. module.exports = {  solidity: "0.8.17",  defaultNetwork: 'goerli',  networks: {    hardhat: {},    goerli: {        url: API_URL_KEY,        accounts: [`0x${PRIVATE_KEY}`]    }  }};</code></pre><p>This code exports a configuration object for the Hardhat Ethereum development framework.</p><p>The dotenv library is being used to load environment variables from a .env file, which allows sensitive information such as private keys to be stored in a separate file that is ignored by version control.</p><p>The API_URL_KEY and PRIVATE_KEY environment variables are being restructured and assigned to constants.</p><p>The configuration object sets the Solidity version to be used as 0.8.17, sets the default network to Goerli, and defines network configurations for the hardhat and Goerli networks. The Goerli network configuration specifies the URL of the Ethereum client to connect to and the private keys of the accounts that will be available for use in transactions.</p><h3><strong>Deployment</strong></h3><p>Now you are ready to deploy your contract to Goerli Network. Wohoo!! The command is almost same as before but now you will mention the goerli network where you are deploying your contract.</p><p>Let's run the command in our terminal and run this project.</p><p><code>npx hardhat run scripts/run.js --network goerli</code></p><p>Once your contract is deployed. You can do the following things.</p><ul><li>Copy your contract address and scan it on <a href="https://goerli.etherscan.io/" target="_blank" rel="noopener noreferrer">Goerli Ethercan</a>. The contract address must have appeared on terminal because of console log.</li><li>Copy the public address of your Metamask wallet and check it on testnets.opensea.io.</li></ul><p>Just like Etherscan, there is a <a href="https://goerli.etherscan.io/" target="_blank" rel="noopener noreferrer">goerli.etherscan.io</a>. This is to help you track your smart contracts and transaction. You can open Goerli testnet and copy paste your deployed contract to see if it is correctly deployed. Lemme show you what I am able to see.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/25808a7322d98d319795d76897d8872ed52d69ead448de06599e660b6f8d0a82/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f7572543745777a4e717865706554326d4f6b7053477a557950793063303544654548376462645a642e706e67" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f7572543745777a4e717865706554326d4f6b7053477a557950793063303544654548376462645a642e706e67" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="2776,1186" style="" data-index="4"></figure></div><p><br>There is an Opensea testnet as well. Here is the <a href="https://testnets.opensea.io/" target="_blank" rel="noopener noreferrer">link to that.</a> You can checkout your minted NFT there as well. Just copy paste the address where you minted your NFT. We minted the NFT to your metamask wallet address. So just copy-paste that address in testnet Opensea and see if you can find your NFT. BOOOMMMM!!!! Here is mine.</p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/c7773193d9b910099206dbb9f65c2d1895e64e5bca9231f5bd6b068056e56b0b/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f6163477951363365334b7a3445524f574366684d746d4875584777773658454b346855575132454f2e706e67" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f6163477951363365334b7a3445524f574366684d746d4875584777773658454b346855575132454f2e706e67" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="792,1072" style="" data-index="5"></figure></div><p>Remember we set some description and properties too. Well, all of that metadata is visible now on OpenSea. <a href="https://testnets.opensea.io/assets/0x90e82d2e3d8d4fd4f090ef5fd939299189aa38b5/1" target="_blank" rel="noopener noreferrer">You can check that directly on this link.</a></p><div class="se-component se-image-container __se__float- __se__float-none" contenteditable="false"><figure style="margin: 0px;"><img src="https://camo.githubusercontent.com/6b6b4d16781a56cff822523f2b7cade7608c086ba1aac88b137d318f6b6ad73c/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f614b3654395133376256667a5a52634533594c32687638786354316e3542396b73646f396a3254672e706e67" alt="" data-origin="," data-proportion="true" data-align="none" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f614b3654395133376256667a5a52634533594c32687638786354316e3542396b73646f396a3254672e706e67" data-file-size="0" data-rotate="" data-rotatex="" data-rotatey="" data-size="," data-percentage="auto,auto" origin-size="782,592" style="" data-index="6"></figure></div><p>And here is the link of the collection on Rarible as we.. <a href="https://rinkeby.rarible.com/collection/0x90e82d2e3d8d4fd4f090ef5fd939299189aa38b5/items" target="_blank" rel="noopener noreferrer">Go check it out here.</a></p><p>And now, all I've got to say is well, well, well done! We have one ☝ last step left, which is, deploying the contract on Production Network, and that's coming up next. 👉</p>

# Launching Your NFT on Testnet

Great work on coming so far! So far, we have been working locally, deploying our NFT into the local server. Now, we will learn how we can deploy our NFT to the blockchain network. For this course, we will use Polygon because it has a great marketplace for NFTs.

## Get started with setting up the testnet network

So, yeah, you must be wondering. I can write, compile, and test my smart contract all day on my computer but how do I connect to the Ethereum network?

Do I have to set up my own Ethereum node on my server?

Won’t that be too complicated?

The answer to all those questions is - [Alchemy](https://www.alchemy.com/).

## Get Alchemy HTTP link

Please follow the following steps to get the HTTP link. We will use this link in our config file to connect our app to the Mumbai network.

1. log in to your Alchemy account or create a new account.
2. Go to this link: [https://dashboard.alchemy.com/apps](https://dashboard.alchemy.com/apps).
3. Create a new app by entering the name and description of the app and clicking on the "Create app" button.
4. Go to the "Network" from the left top options.
5. Choose “Amoy” as your Network at Polygon PoS option.
6. Copy the HTTPS link we will use this later.

You can follow the following boxes to follow the process.
![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L3%20Image%201.webp)

## Create MetaMask wallet

Your metamask wallet is your key to the web3 world. You can interact with the blockchain via a MetaMask account. And of course, generally, it is your digital wallet to store, swap, and buy cryptocurrencies, tokens, NFTs, and other amazing things in the web3 world.

MetaMask has a mobile application and a Chrome browser extension too. I use MetaMask on my Chrome browser extension because I do most of the work on my laptop.

Anyways, let’s go!

Here are the installation steps:

- Go to [MetaMask.io](http://metamask.io/).
- Click Download and Install the Chrome Extension.
- Set up your secure password.
- The next step is the most important one.
- Secure your 12-word phrase properly, never share it with anyone. Write it somewhere because if you lose it, you will never have a way to recover your account. So be mindful of that.

Congrats! Your account is created and you must have received a public address. The public address will be in the pattern of:

_Example: 0x37EA9984481459885141F571907992e7261E837C_

You can use this public address to buy, trade, and store Ethereum-based tokens, cryptos, and NFTs and you can even use it to sign in to websites like OpenSea. But are you wondering if it is safe to share this cryptic long address?

Yes, it is completely safe. You can share this address publicly to accept, buy, trade, or store Ethereum-based crypto.

### Set up the testnet environment

Complete the following steps:

- Head over to [https://chainlist.org/chain/80002](https://chainlist.org/chain/80002).
- 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 Amoy network. 

### Get some fake MATIC $$

Now it's time to get some money!

- Head over to https://faucet.polygon.technology/.
- Make sure you select "Amoy" network.
- Connect your Discord account and follow the steps to verify.
- Copy your account address.
- Paste your wallet address.
- Click on Submit button.
- Wait for a few seconds, you will receive 0.2 MATIC.

See in the following gif how I did it:

![amoy](https://github.com/0xmetaschool/Learning-Projects/assets/130544719/c7d69e7e-ef32-47fb-b8b0-12d5b8227d01)

## 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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history.

1. Open the metamask extension to find your private key.
2. Click on Account.
3. Click on the 3 dots on the right side and go to “Account Details”.
4. Click on “Show private key”.
5. Enter Metamask password.
6. Copy your private key.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L3%20Image%203.webp)

I will tell you how to keep your account and private key safe in the next steps. For now, export the private key and paste it somewhere secure.

DON’T COMMIT YOUR PRIVATE KEY ON GITHUB, DON’T SHARE IT ON DISCORD, DON’T SHARE IT ANYWHERE!

IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUNDS AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.

BE EXTRAAA VIGILANT!!

## Getting Ready for Deployment

First, let’s do some basic housekeeping stuff. We know that massive scams and security issues are happening in the crypto world. You make a mistake and it can cost you a lifetime.

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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. To avoid this issue. Let’s do the following.

```
npm install dotenv --save --force
touch .gitignore
```

Now go ahead and create a .env file at the base of your project. Open your `.gitignore` file and write `.env` there.

All the secrets and important keys related to your project will be stored in a `.env` file and we can access this data whenever and wherever. In the git ignore file we simply write `.env`, it tells git to ignore that file from future commits.

Open the `.env` file you have just created. Add your Metamask Private Key and Alchemy App HTTP URL there. Should be something like this.

```
ALCHEMY_HTTP_URL="YOUR_ALCHEMY_APP_HTTP_URL"
PRIVATE_KEY="YOUR_METAMASK_PRIVATE_KEY"
```

We have gotten most of the things set up already we just have to take care of two little things for now. Next, we will install the `Ethers.js` library.

`Ethers.js` is a very popular library, that makes it easy for us to interact with the Ethereum network. We will be using this library to deploy our smart contract.

To interact with Ethereum, we will also need to set up the network we are using to do so. This tutorial is built on the Mumbai test network which allows developers to test out their software without spending real eth.

## Updating Hardhat Config file

So go to your `hardhat.config.js` file and copy the following settings into it.

```
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config({path: ".env"});

const API_URL_KEY = process.env.ALCHEMY_HTTP_URL;
const PRIVATE_KEY = process.env.PRIVATE_KEY;

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.24",
  networks : {
    polygon_amoy : {
      url: API_URL_KEY,
      accounts: [PRIVATE_KEY],
    },
  },
  
};
```

### Understanding the code

This code exports a configuration object for the Hardhat Ethereum development framework.

The dotenv library is being used to load environment variables from a .env file, which allows sensitive information such as private keys to be stored in a separate file that is ignored by version control.

The `API_URL_KEY` and `PRIVATE_KEY` environment variables are being restructured and assigned to constants.

The configuration object sets the Solidity version to be used as 0.8.17, sets the default network to Mumbai testnet network, and defines network configurations for the hardhat and Mumbai network. The Mumbai network configuration specifies the URL of the Polygon client to connect to and the private keys of the accounts that will be available for use in transactions.

So to check if everything is working properly let’s quickly compile our contract using hardhat.

```
npx hardhat compile
```

The output of the above command will be similar to below:

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L3%20Image%204.webp)

You should be able to see a newly created `artifacts` folder inside your directory. Keep an eye out for this, because we’ll be using this pretty soon.

## Deployment script

First, let’s update our deployment script a bit. Replace your `scripts/run.js` code with the following code.

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

async function main(){

  const deployNFTContract = await ethers.deployContract("ElonNFT");

  const elon = await deployNFTContract.waitForDeployment();

  console.log("Elon contract address is:", await elon.getAddress());

  console.log("Minting NFT...");
  let txn = await elon.mintNFT();
  await txn.wait();
  console.log("Yayy.. NFT minted successfully!!!");
}

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

Here, we are using `deployTransaction` to pay for the transaction fees. `deployTransaction` is used to fetch the transaction fee from your wallet because, without any transaction fee, the contract does not get deployed to your wallet.

`txReceipt.contractAddress` is used to fetch the contract address after the transaction has been completed.

## Run deployment command

Now you are ready to deploy your contract to Polygon Mumbai Network. Wohoo!! The command is almost the same as before but now you will mention the Mumbai network where you are deploying your contract.

Let's run the command in our terminal and run this project.

```
npx hardhat run scripts/run.js --network polygon_amoy
```

Congratulations you have just deployed your smart contract to the Polygon test network!

Store this contract address somewhere. We will need it later.

At this point, I would recommend taking a step back and appreciating what you have done here. 👏

## Viewing your NFT in polygonscan

Go to the [https://amoy.polygonscan.com/](https://amoy.polygonscan.com/) and paste in your contract address. View your transaction details here, click on your transaction hash to understand the elements that were involved in your transaction. I’ll show you mine.

![](https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/assests_for_all/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/L3%20Image%205.webp)

You will probably be using Polygonscan a lot in the future, so it would be helpful to get yourself familiar with it :)

## Viewing your NFT in Opensea

There is an Opensea testnet as well. Here is the [link to that.](https://testnets.opensea.io/) You can check out your minted NFT there as well. Just copy and paste the address where you minted your NFT. We minted the NFT to your metamask wallet address. So just copy-paste that address in testnet Opensea and see if you can find your NFT. BOOOMMMM!!!! Here is mine.

Remember we set some descriptions and properties too. Well, all of that metadata is visible now on OpenSea. [You can check that directly on this link.](https://testnets.opensea.io/assets/0x90e82d2e3d8d4fd4f090ef5fd939299189aa38b5/1)


## Viewing your NFTs in MetaMask

To view your NFTs in your MetaMask account.

- Go to metamask’s mobile app.
- Import your current MetaMask wallet using the recovery phrase.
- And then click on import NFTs.
- Enter your contract address and tokenID (you can find this on polygonscan) of the NFT minted here.
- Refresh MetaMask a few times, and you now have your NFT!

And now, all I've got to say is well, well, well done! We have one ☝ last step left, which is, deploying the contract on Production Network, and that's coming up next.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/3.%20Blockchain%20Environment/1.%20Launching%20Your%20NFT%20on%20Testnet.md

Launching Your NFT on Testnet

<p>As NFTschool, describes it.</p><p>"There are three environments for a blockchain network: mainnet, devnet, and testnet.</p><h3>devnet</h3><p>Till now we were using the local development network to run our smart contracts. This is the easiest and fastest way to get started, iterate and run things without having to setup tons of stuff. For setting up devnet, we used Hardhat that provided us a local ethereum like blockchain environment. Remember at the start of this project, I mentioned, how every time we deploy a smart contract it is a start from scratch. Now we are being promoted. Since we have setup a basic contract which we believe can run. We will use a testnet environment.</p><h3>testnet</h3><p>Because devnets are a simplified simulation of the real network, they don't always behave in quite the same way. This is a good thing when you want fast development cycles, but not so great when you want to know how your contract will actually work on mainnet.</p><p>For that, you can deploy and run your contract on a test network, or <em>testnet</em>. These networks generally run the same code as the mainnet, but they have separate blockchain states and may be configured differently in various ways.</p><h3>mainnet</h3><p>The <em>mainnet</em> is the official production network. It is considered the source of truth, and its tokens can be exchanged for "real world" money in various ways. As you might imagine, using the mainnet for development and testing is an expensive proposition."</p><h3>Setting up the testnet environment</h3><p>We will do the following things.</p><ul><li>Add Goerli network to metamask</li><li>Get some fake ETH for the transaction</li><li>Create a Goerli Network app on Alchemy</li><li>Update our hardhat.config.js file to include the goerli network.</li></ul><h4>Changing your network on MetaMask</h4><p>We will not be using the live/production environment at the moment because it will be expensive to deploy a contract. You will need some real ETH to do that! And of course, learning and deploying contracts on production for the purpose of learning is not sustainable.</p><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 1072px;"><img src="https://camo.githubusercontent.com/36a5e24eba1b8eba416b52b8693afbe0a9b7eabcd6cfae5d9c4f64d83842d00e/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f465778515846536a784d79656173563078764b5a66516a57576831506867366e4c4f72393576694b2e706e67" alt="" data-origin="," data-proportion="true" data-size="1072px,733px" data-align="" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f465778515846536a784d79656173563078764b5a66516a57576831506867366e4c4f72393576694b2e706e67" data-file-size="0" origin-size="2239,1531" style="width: 1072px; height: 733px;" data-index="0"></figure></div><p>We will switch to Goerli Network, it is a test network which pretty much is a simulation of ethereum blockchain production. Just open chrome and switch your network to Goerli, if you are not able to see it.</p><p>Here are the steps to turn on test networks</p><ol><li>Go to settings</li><li>Open Advanced</li><li>Scroll down to Show Test Networks</li><li>Turn on</li></ol><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 1072px;"><img src="https://camo.githubusercontent.com/529780ea7f82fdf6824fe8d71b53ac4f96780a54e2d18a950e79c7d15f100f7c/68747470733a2f2f6c68332e676f6f676c6575736572636f6e74656e742e636f6d2f4a31614139765a636638674533683979704e49326e51302d775279706e434343774e42444874633743397163797a6c6b624f6d6c623649445578784e31784977517066497753505a726d58792d4335685336356c6346494b673555304c5a61586847775f793251784775726d68775a5348634a774b30676b354b43615570753435706d7a386a6c32" alt="" data-origin="," data-proportion="true" data-size="1072px,598px" data-align="" data-file-name="68747470733a2f2f6c68332e676f6f676c6575736572636f6e74656e742e636f6d2f4a31614139765a636638674533683979704e49326e51302d775279706e434343774e42444874633743397163797a6c6b624f6d6c623649445578784e31784977517066497753505a726d58792d4335685336356c6346494b673555304c5a61586847775f793251784775726d68775a5348634a774b30676b354b43615570753435706d7a386a6c32" data-file-size="0" origin-size="1089,607" style="width: 1072px; height: 598px;" data-index="1"></figure></div><h4>&nbsp;</h4><p>Get some fake ETH $$ 🤑</p><p>Try the following website and try to get some fake ETHs. 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 ETH.</p><p>All you have to do is to drop your public address on the following links and the ETH will be transferred.</p><ol><li><a href="https://www.goerlifaucet.com/">https://www.goerlifaucet.com/</a></li></ol><h4>Get your private 🦊 MetaMask key</h4><p>Now let's get open our Metamask wallet and take out the private it. If you don't know how to use Metamask, first take this 5 mins guide on <a href="https://metaschool.so/courses/understand-and-setup-metamask-account">setting up your metamask wallet</a>.</p><p>Open the metamask extension to find your private 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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history.</p><p>Follow the image below to get your Private Key.</p><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 1072px;"><img src="https://camo.githubusercontent.com/18a2dc5674c9450c4ac0c9e2b26d1af0cbb77579cf50e965d49f1083d15c387d/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f785239306f44466777464c674f494e303361496c71466845707855684637523073533961424643522e706e67" alt="" data-origin="," data-proportion="true" data-size="1072px,733px" data-align="" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f785239306f44466777464c674f494e303361496c71466845707855684637523073533961424643522e706e67" data-file-size="0" origin-size="2239,1531" style="width: 1072px; height: 733px;" data-index="2"></figure></div><p>I will tell you how to keep your account and private key safe in the next steps. For now, export private it and paste it somewhere secure. DON'T COMMIT IT ON GITHUB, DONT SHARE IT ON DISCORD, DON'T SHARE IT ANYWHERE! IF YOUR KEY IS PUBLIC, HACKERS AND STEALERS WILL TAKE ALL YOUR FUND AND EVERYTHING THAT IS ASSOCIATED WITH THAT ACCOUNT.</p><p>BE EXTRAAA VIGILANT!!</p><h4>Creating Quick Node ⛓ endpoint</h4><p>Now, we need to set up <a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner">QuickNode</a> with Ethereum testnet nodes, it’s gonna take like 5 mins.</p><p>QuickNode is a platform which helps you access the blockchain environment without going through the hassle of hosting your own node, saving time and resources. This platform lets you access blockchain nodes in a few clicks and you can scale the node performance according to your need thus creating an environment for you to scale your DApp.</p><ul><li><a href="https://www.quicknode.com/?utm_source=partner&amp;utm_campaign=metaschool&amp;utm_content=metaschool-guides&amp;utm_medium=partner">Sign in / Sign up to your QuickNode account</a></li><li>Click on create an QuickNode endpoint</li></ul><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 1072px;"><img src="https://camo.githubusercontent.com/16be74f40874b3818e99a9eafbd3bdc0943b512a7ab7374e732ce4522dc4787f/68747470733a2f2f692e696d6775722e636f6d2f667458384146622e706e67" alt="" data-origin="," data-proportion="true" data-size="1072px,603px" data-align="" data-file-name="68747470733a2f2f692e696d6775722e636f6d2f667458384146622e706e67" data-file-size="0" origin-size="1600,900" style="width: 1072px; height: 603px;" data-index="3"></figure></div><p>Now select Ethereum as Network and Goerli as chain and continue. We don’t need any add-on so click create endpoint now. Your endpoint HTTP address is important, save it somewhere for now, and we will use it in our project later.</p><h2><strong>🌈 Getting Ready for Deployment</strong></h2><p>First let’s do some basic housekeeping stuff. We know that there are massive scams and security issues happening in the crypto world. You make a mistake and it can cost you a life time.</p><p>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. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.</p><pre><code>npm install dotenv --savetouch .gitignore</code></pre><p>Now go ahead and create .env file at the base of your project. Open your .gitignore file and write .env there.</p><p>All the secrets and important keys related to your project will be stored in .env file and we can access this data whenever and wherever. In the gitignore file we simply write .env, it tells git to ignore that file from future commits.</p><p>Open the .env file you have just created. Add your MetaMask Private Key and Alchemy App HTTP URL there. Should be something like this.</p><pre><code>PRIVATE_KEY = YOUR_PRIVATE_KEYAPI_URL_KEY = YOUR_QUICKNODE_APP_URL</code></pre><p>We will update our hardhat config file to setup Goerli Deployment.</p><h4>Updating Hardhat Config file</h4><p>Open your hardhat.config.js file and paste the following code.</p><pre><code>/** * @type import('hardhat/config').HardhatUserConfig */require('dotenv').config(); //all the key value pairs are being made available due to this librequire("@nomicfoundation/hardhat-toolbox"); const {API_URL_KEY, PRIVATE_KEY} = process.env; //environment variables are being loaded here. module.exports = {  solidity: "0.8.17",  defaultNetwork: 'goerli',  networks: {    hardhat: {},    goerli: {        url: API_URL_KEY,        accounts: [`0x${PRIVATE_KEY}`]    }  }};</code></pre><p>This code exports a configuration object for the Hardhat Ethereum development framework.</p><p>The dotenv library is being used to load environment variables from a .env file, which allows sensitive information such as private keys to be stored in a separate file that is ignored by version control.</p><p>The API_URL_KEY and PRIVATE_KEY environment variables are being destructured and assigned to constants.</p><p>The configuration object sets the Solidity version to be used as 0.8.17, sets the default network to goerli, and defines network configurations for the hardhat and goerli networks. The goerli network configuration specifies the URL of the Ethereum client to connect to and the private keys of the accounts that will be available for use in transactions.</p><h3>Deployment</h3><p>Now you are ready to deploy your contract to Goerli Network. Wohoo!! The command is almost same as before but now you will mention the goerli network where you are deploying your contract.</p><p>Let's run the command in our terminal and run this project.</p><pre><code>npx hardhat run scripts/run.js --network goerli</code></pre><p>Once your contract is deployed. You can do the following things.</p><ul><li>Copy your contract address and scan it on <a href="https://goerli.etherscan.io/">Goerli Ethercan</a>. The contract address must have appeared on terminal because of console log.</li><li>Copy the public address of your metamask wallet and check it on testnets.opensea.io.</li></ul><p>Just like etherscan, there is a <a href="https://goerli.etherscan.io/">goerli.etherscan.io</a>. This is to help you track your smart contracts and transaction. You can open goerli testnet and copy paste your deployed contract to see if it is correctly deployed. Lemme show you what I am able to see.</p><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 1072px;"><img src="https://camo.githubusercontent.com/25808a7322d98d319795d76897d8872ed52d69ead448de06599e660b6f8d0a82/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f7572543745777a4e717865706554326d4f6b7053477a557950793063303544654548376462645a642e706e67" alt="" data-origin="," data-proportion="true" data-size="1072px,458px" data-align="" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f7572543745777a4e717865706554326d4f6b7053477a557950793063303544654548376462645a642e706e67" data-file-size="0" origin-size="2776,1186" style="width: 1072px; height: 458px;" data-index="4"></figure></div><p><br>There is an opensea testnet as well. Here is the <a href="https://testnets.opensea.io/">link to that.</a> You can checkout your minted NFT there as well. Just copy paste the address where you minted your NFT. We minted the NFT to your metamask wallet address. So just copy-paste that address in testnet opensea and see if you can find your NFT. BOOOMMMM!!!! Here is mine.</p><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 792px;"><img src="https://camo.githubusercontent.com/c7773193d9b910099206dbb9f65c2d1895e64e5bca9231f5bd6b068056e56b0b/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f6163477951363365334b7a3445524f574366684d746d4875584777773658454b346855575132454f2e706e67" alt="" data-origin="," data-proportion="true" data-size="792px,1072px" data-align="" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f6163477951363365334b7a3445524f574366684d746d4875584777773658454b346855575132454f2e706e67" data-file-size="0" origin-size="792,1072" style="width: 792px; height: 1072px;" data-index="5"></figure></div><p>Remember we set some description and properties too. Well, all of that metadata is visible now on OpenSea. <a href="https://testnets.opensea.io/assets/0x90e82d2e3d8d4fd4f090ef5fd939299189aa38b5/1">You can check that directly on this link.</a></p><div class="se-component se-image-container __se__float-" contenteditable="false"><figure style="margin: 0px; width: 782px;"><img src="https://camo.githubusercontent.com/6b6b4d16781a56cff822523f2b7cade7608c086ba1aac88b137d318f6b6ad73c/68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f614b3654395133376256667a5a52634533594c32687638786354316e3542396b73646f396a3254672e706e67" alt="" data-origin="," data-proportion="true" data-size="782px,592px" data-align="" data-file-name="68747470733a2f2f6d6574617363686f6f6c2e73332d61702d736f757468656173742d312e616d617a6f6e6177732e636f6d2f696d616765732f614b3654395133376256667a5a52634533594c32687638786354316e3542396b73646f396a3254672e706e67" data-file-size="0" origin-size="782,592" style="width: 782px; height: 592px;" data-index="6"></figure></div><p>And here is the link of the collection on Rarible as we.. <a href="https://rinkeby.rarible.com/collection/0x90e82d2e3d8d4fd4f090ef5fd939299189aa38b5/items">Go check it out here.</a></p><p>And now, all I've got to say is well, well, well done! We have one ☝ last step left, which is, deploying the contract on Production Network, and that's coming up next. 👉</p>

# Launching Your Elon Musk NFT on Mainnet

Note: This is not a mandatory part of this course. I wanted to give everyone a taste of mainnet hence I am sharing details on how to mint an NFT on mainnet. Feel free to skim or skip this section and get to complete your course.

In the last section, I mentioned that mainnet is the place we should strive for to mint our NFT. But it does require real $$$.

Ethereum mainnet is gonna be an expensive choice for us. So I am gonna go ahead and use Polygon Network. Polygon is a Level 2 Ethereum Network that can help with fast transactions and minting of your NFT with almost ZERO fees.

## Setting up the environment

Just like how we setup our testnet, we will set up Polygon mainnet. We will do the following things:

- [Add Polygon network to metamask](https://wiki.polygon.technology/docs/develop/metamask/config-polygon-on-metamask/)
- Get some MATIC tokens for the transaction
- Create a Polygon app on Alchemy
- Update our `hardhat.config.js` file to include the polygon mainnet.

So let's do this step by step.

### Adding Polygon Network to MetaMask

Complete the following steps:

- Head over to [https://chainlist.org/chain/137](https://chainlist.org/chain/137).
- 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 Polygon network.

### Get some MATIC tokens

The Polygon network uses MATIC tokens. Let’s add these tokens to our wallet so we can pay deployment fees!

You have two options here:

Purchase $MATIC on an exchange like Binance, Coinbase, etc, and transfer it to your MetaMask wallet.

Once you have MATIC tokens, we are good to go to the next step. 🎉

### Create a Polygon App on Alchemy

Just like the steps we followed for testnet, now let's create a production-level application. Choose Polygon as Chain and Polygon Mainnet as Network. Hit Create app.

Click on your newly created app in the dashboard, click “View Key” in the upper right-hand corner, and copy the HTTP URL — we’ll come back to this in a second. Just like before, we will add all the credentials to the .env file that we create.

### Update hardhat config.

This is the easiest part, we will change the network name to `matic`. We will also copy the HTTP URL of our Alchemy app and paste in the URL section in the `.env` file. The private key will be the same as before – your MetaMask wallet private key.

```
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config({path: ".env"});

const API_URL_KEY = process.env.ALCHEMY_HTTP_URL;
const PRIVATE_KEY = process.env.PRIVATE_KEY;

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.20",
  networks : {
    matic : {
      url: API_URL_KEY,
      accounts: [PRIVATE_KEY],
    },
  },
  
};
```

### Compile and Run

Now we are getting to the easiest and last part. Open the terminal in your project's folder and run the following commands.

```
npx hardhat compile
npx hardhat run scripts/run.js --network matic
```

You should see something like this in the terminal output.

```
Deploying Contract...
Contract deployed to address: 0xdaa623a5E6c88194C9eadcd926a27281ed70479F
ElonNFT is minted...
```

Whoa! this is the real contract address. I can just go to [PolygonScan mainnet](https://polygonscan.com/) and check this contract.

Remember we mined the NFT to the address of the person calling the contract. Since the caller was me, the NFT will be minted to my personal OpenSea account and Rarible account too. Let me share what I can see.

Here is the link to the minted NFT in my OpenSea account: [https://opensea.io/assets/matic/0x6feb0c5c713547a27a73ed977beb8ab9fc1f8205/1](https://opensea.io/assets/matic/0x6feb0c5c713547a27a73ed977beb8ab9fc1f8205/1)

Here is the link to the collection on OpenSea: [https://opensea.io/collection/elonmusk-uwob1hkl8b](https://opensea.io/collection/elonmusk-uwob1hkl8b)

### Parting thoughts!

I had so much fun building this with you and learning things along the way too. Just to revise for everyone, in this project we learned:

1. How to write a hello world solidity smart contract.
2. How to write, build and ship an NFT in local environment, testnet environment and mainnet.
3. How to check your NFT contract on Etherscan, Polygonscan and other platforms.
4. How to create NFT with JSON metadata.
5. How to connect with alchemy network.

So much learning in such a short period.

AMAZING! HUGE ROUND OF APPLAUSE FOR ALL OF US!! SPECIALLY THOSE WHO REACHED THE FINISH LINE!!

## ⚒️ 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/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea). 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 grateful! ❤️
2. We are a completely free platform and we aim to stay the same, so please consider following us on [X](https://bit.ly/elon-nft-twitter) and [LinkedIn](https://bit.ly/elon-nft-linkedin) as well. 🫶


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/How%20to%20write%20a%20smart%20contract%20and%20mint%20Elon%20Musk%20NFT%20on%20OpenSea/3.%20Blockchain%20Environment/2.%20Launching%20Your%20Elon%20Musk%20NFT%20on%20Mainnet.md

Launching Your Elon Musk NFT on Mainnet

Write an Elon Musk NFT Smart Contract on OpenSea

Build a One Piece Personality dApp is an exciting course that tests your Solidity skills and anime knowledge both. In this one-of-its-kind Metaschool course, you will get to build a One Piece Personality dApp and make it choose one of the five One Piece characters for you. Then, you will learn to code the logic in smart contracts, deploy it, and integrate it into a React frontend to interact with it. So get ready to work on a dApp based on the greatest anime airing for the last 30 years.

# What Are We Building Today

gm everyone ☀️ We are very excited to bring the course where you will build a project in Solidity to help you become a Solidity and dApp creation master.

So what are we building today? We will be building our very own One Piece Personality dApp. Yes, you heard it right, this is inspired by the anime classic, One Piece and we decided to test out which One Piece character you and your friends most resemble. This project will not only be super fun for you but will also equip you with the potential to build dApp in the web3 ecosystem.

Why Solidity? Solidity is the most popular language of web3 and is in demand too! There are ~200,000 Solidity developers and their maximum yearly salary is $250k. On average, 128 new jobs for Solidity developers are posted every month. 


Okay, before we start, why don’t we try out the dApp first? [Click here](https://onepiece-dapp.vercel.app/) to try out the fun dApp. Or see in the gif below, how it looks like:

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/interact.webp?raw=true)

## Course Overview

We will:

1. Set up basic project using Hardhat
2. Learn how to code One Piece personality sorting in Solidity
3. Deploy the smart contracts on the Arbitrum Sepolia Testnet
4. Learn how to use Chainlink VRF and The Graph Protocol
5. Set up the React frontend and integrate it with the Solidity smart contract (backend)
6. Deploy the final dApp and interact with it

- **Keep your momentum going! After the 4th lesson, I’ll teach the most exciting part of the course which I can’t wait to tell you about.**

## Who exactly should take this course?

This course is for intermediate web3 developers who want to upskill their dApp building and Solidity command. You should have a basic knowledge of blockchain, [consensus mechanism](https://metaschool.so/articles/consensus-mechanism-meaning/), Solidity Programming language, and frontend technologies because in this course we will focus more on building and deploying our dApp. Don’t worry! If you don’t know the basics we got you covered, you can always reach out to us for any help.

## Prerequisites

- MetaMask extension installed in your browser ([Chrome extension link](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn))

> **Note:** Please refer to [this course](https://metaschool.so/courses/understand-and-setup-metamask-account) to setup your MetaMask if you still hasn’t. Come back to this course after you have set it up.
> 

## Proof of completion

If you complete this course with me today, you will be getting a special NFT, a utility token, which will unlock many more opportunities for you on the Metaschool platform. Here is what the NFT looks like.

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

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

1. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/airbnb-dapp-fuel-twitter) and [LinkedIn](https://bit.ly/airbnb-dapp-fuel-linkedin), it would be a great support. 🫣
4. Stay happy and positive!

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

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Building%20Today.md

# Set Up Your Project

Greetings folks! Let’s dive right into setting up our project. Let’s go!!

## Prerequisites to setting up your project

- Make sure you have [Visual Studio Code](https://code.visualstudio.com/download) installed in your system.
- Make sure you have installed a [node](https://nodejs.org/en/download) in your system. If the node is installed, make sure it is up-to-date. We are using `v18.17.1`. You can check yours using the `node --version` command.
- If you do not have the MetaMask extension, you can install it in your browser using the [Chrome extension link](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn).

## Setting up the testnet environment

Now we need to set the testnet network so we can deploy our app on it. Complete the following steps to set it up:

- Head over to [https://chainlist.org/chain/421614](https://chainlist.org/chain/421614).
- Click on the “Add to Metamask” button.
    
    ![setup-metamask-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20Your%20Project/setup-metamask-1.webp?raw=true)
    

- Click on “Approve” and then “Switch network”.

You will be successfully connected to the Arbitrum Sepolia network. See in the following gif how we did it:

![connect-metamask-2.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20Your%20Project/connect-metamask-2.webp?raw=true)

### Get some fake ETH $$ 🤑

Now it's time to get some money, just like Nami!

- Copy your account address from MetaMask.
- Head over to [https://www.alchemy.com/faucets/arbitrum-sepolia](https://www.alchemy.com/faucets/arbitrum-sepolia).
- Paste your wallet address.
- Click on the “Send Me ETH” button.
- You will receive 0.5 ETH.

Note: If you face any issues, first sign up or sign in to your Alchemy account and then try again.

## Set up the Hardhat project

Open your terminal and run the following commands:

```
mkdir one-piece-dapp
cd one-piece-dapp
npm install --save-dev hardhat 
```

Initialize a new Hardhat project using the following command:

```
npx hardhat init
```

You will see an output like shown below. Select Javascript project and hit Enter for all other options:

![hardhat-setup.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20Your%20Project/hardhat-setup.webp?raw=true)

Install all dependencies using the following command:

```
npm install @nomicfoundation/hardhat-toolbox dotenv @openzeppelin/contracts@^4.9.6 @chainlink/contracts@^0.8.0
```

Just like Sunny Go is always ready to take our crew anywhere they want; our development environment is also set to take us to the next level. I hope you got my One Piece reference…..

## Wrap up

In this lesson, we got some fake ETHs, set up our Hardhat project, and installed the necessary dependencies. Next, we will learn to secure necessary data.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/1.%20Let%E2%80%99s%20Get%20Started/2.%20Set%20Up%20Your%20Project.md

Set Up Your Project

# Secure Your Data

Greetings folks! We have set up our project. Now we need private data to deploy the contracts so let’s see how we can secure that. And we will also fetch some API keys and other data that will be required later. Ikuzo (Let’s go!!)

## Create `.env` file

Let’s use `.env` file to store all the secrets and important keys related to your project so we can access this data whenever and wherever.

Create a file named `.env` in the folder `one-piece-dapp` and copy the following data in the file:

```
PRIVATE_KEY=<your-private-key>
SUB_ID=<your-chainlink-vrf-subscription-id>
VRF_ADDRESS=<your-chainlink-vrf_address-id>
KEY_HASH=<your-chainlink-key_hash-id>
API_KEY=<your-abiscan-api>
```

- If a `gitignore` file is not created, create a file named `.gitignore` file in the folder `one-piece-dapp`. In the `gitignore` file, we’ll simply write `.env`, so that it tells git to ignore that file from future commits. And we do not accidentally push our secret data to the public.

## 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. Now if that private key is made visible, the hackers can gain access to your account and then the rest will be history.

1. Open the MetaMask extension to find your private key. 
2. Click on Account.
3. Click on the three dots on the right side and go to “Account Details”.
4. Click on “Show private key”.
5. Enter MetaMask password.
6. Copy your private key.
7. Replace `<your-private-key>` with your private key in the `.env` file.
    
    ![reveasl-privatekey.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/reveasl-privatekey.webp?raw=true)
    

## AbI scan API key

Now you need to have an API so follow the steps given below:

- Head over to [https://arbiscan.io/](https://arbiscan.io/).
- Login or signup to Abiscan. If you are signing up, make sure to verify your email address.
- After logging in, go to “API-KEYs” on the left navigation bar.
- If you don’t have an API key. Generate one by clicking on “+Add” button and giving an app name such as “one-piece-dapp”.
- After generating the key, copy your Api-Key Token.
    
    ![abiscan.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/abiscan.webp?raw=true)
    
- Replace `<your-abiscan-api>` with yours in the `.env` file.

## Chainlink

Follow the steps given below:

- Head over to [https://vrf.chain.link/arbitrum-sepolia](https://vrf.chain.link/arbitrum-sepolia).
- Click on “Connect wallet” and connect your MetaMask wallet.
- Copy “VRF Coordinator” and replace `<your-chainlink-vrf_address-id>` with yours in the `.env` file. I have pointed out the address in the following image for your ease.
    
    ![chainlink-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/chainlink-1.webp?raw=true)
    

- Copy the “Key Hash” address and replace `<your-chainlink-key_hash-id>` with yours in the `.env` file. I have pointed out the hash in the following image for your ease.
    
    ![chainlink-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/chainlink-2.webp?raw=true)
    

### Create subscription

- Next, click on Create Subscription:
    - Click on the “Create Subscription” button.
        
        ![chainlink-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/chainlink-3.webp?raw=true)
        
    - Sign the transaction.
    - Confirm the transaction.
        
        ![chainlink-3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/chainlink-3.webp?raw=true)
        
    - Wait for a few seconds. Click on the “Add Funds” pop-up but move to the home page without adding any link.
- Now go back to “Home”. Under “My Subscriptions”, you’ll find the subscription you created just yet. Click on it and copy the subscription ID.
    
    ![chainlink-4.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/chainlink-4.webp?raw=true)
    
- Replace `<your-chainlink-vrf-subscription-id>` with your ID in the `.env` file.
    
    ![chainlink-5.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/chainlink-5.webp?raw=true)
    
### Fund your subscription

Now, we need to fund our subscription. Without adding funds to the subscription ID, you may face errors.

1. Click on the “Action” button present on the Subscription page.
2. Click on the “Fund Subscription” option.
    
    ![fund-subscription-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/fund-subscription-1.webp?raw=true)
    
3. Click on “Visit the Chainlink Arbitrum Sepolia Faucet” link and request “25 test LINK”.
    
    ![fund-subscription-3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/fund-subscription-3.webp?raw=true)
    
4. Go back to Subscription page and enter 15 in the “Add Funds (LINK)” field and click on “Confirm” button.
    
    ![fund-subscription-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Secure%20Your%20Data/fund-subscription-4.webp?raw=true)
    
Awesome, setting all of this was a lot but you did great! Now, you are all set up to start writing the code!

## Wrap up

In this lesson, we have learned how to secure our data using a `.env` file. Then we fetched the required data and utilized MetaMask wallet, Arbitrum faucet, ABIscan API, and Chainlink for that. 

Now that our development environment is ready, we can move on to building our dApp. Stay tuned for the next adventure!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/1.%20Let%E2%80%99s%20Get%20Started/3.%20Secure%20Your%20Data.md

Secure Your Data

# Let’s Get Started With the Contract

Oi, oi, oi, welcome back! We are done with setting up our project. Now, it’s time to code!! Woohoo, let’s start coding!

## Create a file

Navigate to the `contracts` directory. Delete the existing `Lock.sol` file as we do not need it. 

Create a new Solidity file called `OnePieceMint.sol` in the `contracts` directory.

## Write code

We will write the `OnePieceMint` smart contract that does the following:

- Allows the owner to mint non-fungible tokens representing the five One Piece characters.
- Randomly assign a character to a user based on the questions asked via frontend.
- Create a string of IPFS links of character NFTs.
- Make the tokens soul-bound within the One Piece context.

So why wait, let’s go!

### Import dependencies

We will start our Solidity file by importing the dependencies like any other smart contract.

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

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
```

- First of all, we are importing chainlink smart contracts. We need these smart contracts for randomness. VRF chainlink is a random number generator that enables smart contracts to access random values. This generator will help us assign characters to users randomly.
- Openzeppelin smart contracts are used to create an ERC721 non-fungible token contract.

### Create a smart contract

Create the `OnePieceMint` smart contract that inherits all the contracts we have imported.

```
contract OnePieceMint is VRFConsumerBaseV2Plus, ERC721, ERC721URIStorage {
	 // Contract code goes here
}
```

From now on, we will add the code to the `OnePieceMint` contract.

### Add character NFTs URIs

For your ease, we have already created the metadata files and uploaded them to Pinata to create the IPFS files. You can create your NFTs by following the following steps:

1. Create an account on Pinata.
2. Upload image files to Pinata.
3. Create metadata JSON files using Pinata image links.
4. Upload metadata files to Pinata.
5. Use metadata file links in your code.

Here’s how we have created the URIs string for five One Piece characters.

```
string[] internal characterTokenURIs = [
		"https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmNp4sHf4ccqPpqMBUCSG1CpFwFR4D6kgHesxc1mLs75am",
		"https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmPHaFt55PeidgCuXe2kaeRYmLaBUPE1Y7Kg4tDyzapZHy",
		"https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmP9pC9JuUpKcnjUk8GBXEWVTGvK3FTjXL91Q3MJ2rhA16",
		"https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmSnNXo5hxrFnpbyBeb7jY7jhkm5eyknaCXtr8muk31AHK",
		"https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmarkkgDuBUcnqksatPzU8uNS4o6LTbEtuK43P7Jyth9NH"
];
```

### Add local variables

As always, we will create multiple local variables that will help us store important data in the smart contract.

```
uint256 private s_tokenCounter; // Used to keep track of the number of NFTs being minted
VRFCoordinatorV2Interface private i_vrfCoordinator; // Used to store VRF coordinator link
uint64 private i_subscriptionId; // Used to store subscription ID from VRF chainlink
bytes32 private i_keyHash; // Used to store key hash from VRF chainlink
uint32 private i_callbackGasLimit; // Used to specify the gas limit
```

### Add mappings

We will declare several mappings to store relationships between `requestId` and sender, user and their chosen character, address and whether they have minted, and address and the character they got.

```
mapping(uint256 => address) private requestIdToSender; // allows the contract to keep track of which address made a request
mapping(address => uint256) private userCharacter; // enables the contract to associate each user with their selected character
mapping(address => bool) public hasMinted; // prevents users from minting multiple NFTs with the same address
mapping(address => uint256) public s_addressToCharacter; // allows users to query which character they received based on their address
```

### Add events

We will declare events to log NFT requests, character traits determined, and NFTs minted.

```
event NftRequested(uint256 requestId, address requester);
event CharacterTraitDetermined(uint256 characterId);
event NftMinted(uint256 characterId, address minter);
```

### Add a constructor function

Creating a constructor for each contract is essential. In our case, we will create a constructor as follows.

```
constructor(
        address vrfCoordinatorV2Address,
        uint256 subscriptionId,
        bytes32 keyHash,
        uint32 callbackGasLimit
    ) VRFConsumerBaseV2Plus(vrfCoordinatorV2Address) ERC721("OnePiece NFT", "OPN") {
        s_subscriptionId = subscriptionId;
        i_keyHash = keyHash;
        i_callbackGasLimit = callbackGasLimit;
    }
```

The constructor function takes VRF chainlink data and initializes the contract variables.

### Creating the minting function

As we’re done with all the essentials, let’s come to real business and create the minting function that will officially mint the character NFT.

```
function mintNFT(address recipient, uint256 characterId) internal {
    // Ensure the address has not been minted before
    require(!hasMinted[recipient], "You have already minted your house NFT");

    // Get the next available token ID
    uint256 tokenId = s_tokenCounter;

    // Mint the NFT and assign it to the recipient
    _safeMint(recipient, tokenId);

    // Set the token URI for the minted NFT based on the character ID
    _setTokenURI(tokenId, characterTokenURIs[characterId]);

    // Map the recipient's address to the character ID they received
    s_addressToCharacter[recipient] = characterId;

    // Increment the token counter for the next minting
    s_tokenCounter += 1;

    // Mark the recipient's address as having minted an NFT
    hasMinted[recipient] = true;

    // Emit an event to log the minting of the NFT
    emit NftMinted(characterId, recipient);
}
```

### Creating the requestNFT function

The `requestNFT` function determines the character based on the answers, requests random words from the VRF coordinator, and emits an event.

```
 function requestNFT(uint256[5] memory answers) public {
        userCharacter[msg.sender] = determineCharacter(answers);

        uint256 requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: i_keyHash,
                subId: s_subscriptionId,
                requestConfirmations: i_requestConfirmations,
                callbackGasLimit: i_callbackGasLimit,
                numWords: i_numWords,
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({
                        nativePayment: false
                    })
                )
            })
        );
        requestIdToSender[requestId] = msg.sender;
        emit NftRequested(requestId, msg.sender);
    }
```

## Complete code so far

Let’s compile the code we have written so far and get a bird’s eye view.

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

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract OnePieceMint is VRFConsumerBaseV2Plus, ERC721, ERC721URIStorage {
    uint256 private s_tokenCounter;

    string[] internal characterTokenURIs = [
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmNp4sHf4ccqPpqMBUCSG1CpFwFR4D6kgHesxc1mLs75am",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmPHaFt55PeidgCuXe2kaeRYmLaBUPE1Y7Kg4tDyzapZHy",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmP9pC9JuUpKcnjUk8GBXEWVTGvK3FTjXL91Q3MJ2rhA16",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmSnNXo5hxrFnpbyBeb7jY7jhkm5eyknaCXtr8muk31AHK",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmarkkgDuBUcnqksatPzU8uNS4o6LTbEtuK43P7Jyth9NH"
    ];

    uint256 public s_subscriptionId;
    bytes32 private i_keyHash;
    uint32 private i_callbackGasLimit;
    uint16 private i_requestConfirmations = 3;
    uint32 private i_numWords = 1;

    mapping(uint256 => address) private requestIdToSender;
    mapping(address => uint256) private userCharacter;
    mapping(address => bool) public hasMinted;
    mapping(address => uint256) public s_addressToCharacter;
    mapping(address => uint256) public userTokenID;

    event NftRequested(uint256 requestId, address requester);
    event CharacterTraitDetermined(uint256 characterId);
    event NftMinted(uint256 characterId, address minter);

    constructor(
        address vrfCoordinatorV2Address,
        uint256 subscriptionId,
        bytes32 keyHash,
        uint32 callbackGasLimit
    ) VRFConsumerBaseV2Plus(vrfCoordinatorV2Address) ERC721("OnePiece NFT", "OPN") {
        s_subscriptionId = subscriptionId;
        i_keyHash = keyHash;
        i_callbackGasLimit = callbackGasLimit;
    }

    function mintNFT(address recipient, uint256 characterId) internal {
        require(!hasMinted[recipient], "You have already minted your house NFT");

        uint256 tokenId = s_tokenCounter;
        _safeMint(recipient, tokenId);
        _setTokenURI(tokenId, characterTokenURIs[characterId]);

        s_addressToCharacter[recipient] = characterId;
        userTokenID[recipient] = tokenId;

        s_tokenCounter += 1;
        hasMinted[recipient] = true;

        emit NftMinted(characterId, recipient);
    }

    function requestNFT(uint256[5] memory answers) public {
        userCharacter[msg.sender] = determineCharacter(answers);

        uint256 requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: i_keyHash,
                subId: s_subscriptionId,
                requestConfirmations: i_requestConfirmations,
                callbackGasLimit: i_callbackGasLimit,
                numWords: i_numWords,
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({
                        nativePayment: false
                    })
                )
            })
        );
        requestIdToSender[requestId] = msg.sender;
        emit NftRequested(requestId, msg.sender);
    }
```

## That’s a wrap

So far, we have implemented the minting and requesting NFT functionality in our `OnePieceMint` contract. Next, we will implement the randomness functionalities that will help us assign random characters to a specific address. Also, we will add some other essential functionalities.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/2.%20Build%20One%20Piece%20Contract/1.%20Let%E2%80%99s%20Get%20Started%20With%20the%20Contract.md

Let’s Get Started With the Contract

# Add Randomness to Our Contract

Oi, oi, oi, it's time to complete our `OnePieceMint` contract. So, without any wait let’s dive in.

## Continue building the One Piece dApp

Lastly, we added the minting and requesting NFTs functionalities. Now, let’s use VRF chainlink and use randomness to assign characters to the user.

### Creating the `fulfillRandomWords` functions

The `fulfillRandomWords` function is responsible for generating a final character ID based on the user's traits and a random value obtained from a verifiable random function (VRF).

```
  function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal override {
        address nftOwner = requestIdToSender[requestId];
        uint256 traitBasedCharacterId = userCharacter[nftOwner];

        uint256 randomValue = randomWords[0];
        uint256 randomCharacterId = (randomValue % 5);

        uint256 finalCharacterId = (traitBasedCharacterId + randomCharacterId) % 5;
        mintNFT(nftOwner, finalCharacterId);
    }

    function determineCharacter(uint256[5] memory answers) private returns (uint256) {
        uint256 characterId = 0;
        for (uint256 i = 0; i < 5; i++) {
            characterId += answers[i];
        }
        characterId = (characterId % 5) + 1;
        emit CharacterTraitDetermined(characterId);
        return characterId;
    }

    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
        require(from == address(0) || to == address(0), "Err! This is not allowed");
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function _burn(uint256 tokenId)
        internal
        override(ERC721, ERC721URIStorage)
    {
        super._burn(tokenId);
    }
}
```

### Determine the character

We will implement the `determineCharacter` function to calculate the character ID based on the sum of answers and return the result.

```
function determineCharacter(uint256[5] memory answers) private returns (uint256) {
    // Initialize characterId variable to store the calculated character ID
    uint256 characterId = 0;

    // Loop through each answer provided in the answers array
    for (uint256 i = 0; i < 5; i++) {
        // Add each answer to the characterId variable
        characterId += answers[i];
    }

    // Calculate the final character ID by taking the remainder when divided by 5 and adding 1
    characterId = (characterId % 5) + 1;

    // Emit an event to log the determination of the character traits
    emit CharacterTraitDetermined(characterId);

    // Return the final character ID
    return characterId;
}
```

### Override functions

At last, we will override some of the ERC721 and ERC721URIStorage functions to make them work according to our needs.

```
// Override the transfer functionality of ERC721 to make it soulbound
// This function is called before every token transfer to enforce soulbinding
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual override {
    // Call the parent contract's implementation of _beforeTokenTransfer
    super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

    // Ensure that tokens are only transferred to or from the zero address
    require(from == address(0) || to == address(0), "Err! This is not allowed");
}

// Override the tokenURI function to ensure compatibility with ERC721URIStorage
function tokenURI(uint256 tokenId)
    public
    view
    override(ERC721, ERC721URIStorage)
    returns (string memory)
{
    // Call the parent contract's implementation of tokenURI
    return super.tokenURI(tokenId);
}

// Override the supportsInterface function to ensure compatibility with ERC721URIStorage
function supportsInterface(bytes4 interfaceId)
    public
    view
    override(ERC721, ERC721URIStorage)
    returns (bool)
{
    // Call the parent contract's implementation of supportsInterface
    return super.supportsInterface(interfaceId);
}

// Override the _burn function to ensure compatibility with ERC721URIStorage
function _burn(uint256 tokenId)
    internal
    override(ERC721, ERC721URIStorage)
{
    // Call the parent contract's implementation of _burn
    super._burn(tokenId);
}
```

## Complete code

At last, the complete `OnePieceMint` contract will look like this:

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

import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract OnePieceMint is VRFConsumerBaseV2Plus, ERC721, ERC721URIStorage {
    uint256 private s_tokenCounter;

    string[] internal characterTokenURIs = [
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmNp4sHf4ccqPpqMBUCSG1CpFwFR4D6kgHesxc1mLs75am",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmPHaFt55PeidgCuXe2kaeRYmLaBUPE1Y7Kg4tDyzapZHy",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmP9pC9JuUpKcnjUk8GBXEWVTGvK3FTjXL91Q3MJ2rhA16",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmSnNXo5hxrFnpbyBeb7jY7jhkm5eyknaCXtr8muk31AHK",
        "https://scarlet-live-iguana-759.mypinata.cloud/ipfs/QmarkkgDuBUcnqksatPzU8uNS4o6LTbEtuK43P7Jyth9NH"
    ];

    uint256 public s_subscriptionId;
    bytes32 private i_keyHash;
    uint32 private i_callbackGasLimit;
    uint16 private i_requestConfirmations = 3;
    uint32 private i_numWords = 1;

    mapping(uint256 => address) private requestIdToSender;
    mapping(address => uint256) private userCharacter;
    mapping(address => bool) public hasMinted;
    mapping(address => uint256) public s_addressToCharacter;
    mapping(address => uint256) public userTokenID;

    event NftRequested(uint256 requestId, address requester);
    event CharacterTraitDetermined(uint256 characterId);
    event NftMinted(uint256 characterId, address minter);

    constructor(
        address vrfCoordinatorV2Address,
        uint256 subscriptionId,
        bytes32 keyHash,
        uint32 callbackGasLimit
    ) VRFConsumerBaseV2Plus(vrfCoordinatorV2Address) ERC721("OnePiece NFT", "OPN") {
        s_subscriptionId = subscriptionId;
        i_keyHash = keyHash;
        i_callbackGasLimit = callbackGasLimit;
    }

    function mintNFT(address recipient, uint256 characterId) internal {
        require(!hasMinted[recipient], "You have already minted your house NFT");

        uint256 tokenId = s_tokenCounter;
        _safeMint(recipient, tokenId);
        _setTokenURI(tokenId, characterTokenURIs[characterId]);

        s_addressToCharacter[recipient] = characterId;
        userTokenID[recipient] = tokenId;

        s_tokenCounter += 1;
        hasMinted[recipient] = true;

        emit NftMinted(characterId, recipient);
    }

    function requestNFT(uint256[5] memory answers) public {
        userCharacter[msg.sender] = determineCharacter(answers);

        uint256 requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: i_keyHash,
                subId: s_subscriptionId,
                requestConfirmations: i_requestConfirmations,
                callbackGasLimit: i_callbackGasLimit,
                numWords: i_numWords,
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({
                        nativePayment: false
                    })
                )
            })
        );
        requestIdToSender[requestId] = msg.sender;
        emit NftRequested(requestId, msg.sender);
    }

    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal override {
        address nftOwner = requestIdToSender[requestId];
        uint256 traitBasedCharacterId = userCharacter[nftOwner];

        uint256 randomValue = randomWords[0];
        uint256 randomCharacterId = (randomValue % 5);

        uint256 finalCharacterId = (traitBasedCharacterId + randomCharacterId) % 5;
        mintNFT(nftOwner, finalCharacterId);
    }

    function determineCharacter(uint256[5] memory answers) private returns (uint256) {
        uint256 characterId = 0;
        for (uint256 i = 0; i < 5; i++) {
            characterId += answers[i];
        }
        characterId = (characterId % 5) + 1;
        emit CharacterTraitDetermined(characterId);
        return characterId;
    }

    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);
        require(from == address(0) || to == address(0), "Err! This is not allowed");
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return super.tokenURI(tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function _burn(uint256 tokenId)
        internal
        override(ERC721, ERC721URIStorage)
    {
        super._burn(tokenId);
    }
}
```

## That’s a wrap

That’s pretty much it! Our OnePieceMint contract is ready for deployment. Next, we will deploy the contract.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/2.%20Build%20One%20Piece%20Contract/2.%20Add%20Randomness%20to%20Our%20Contract.md

Add Randomness to Our Contract

# Deploy Your One Piece Contract

Welcome back! You did great in the last lesson, coding all smart contracts. This lesson will teach you to set up your deployment script, config file, and finally deploy our smart contract. Let’s start this awesome journey!

## Creating the deployment script

Navigate to the `scripts` folder and remove the existing content of `deploy.js`. Let’s write our new code in `deploy.js`. The complete code for `deploy.js`:

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

async function main() {
  
  const [deployer] = await ethers.getSigners();
  console.log("Deploying contracts with the account:", deployer.address);

  const vrfCoordinatorV2Address = process.env.VRF_ADDRESS; // address of the VRFCoordinatorV2 contract
  const subId = process.env.SUB_ID; // subscription ID for Chainlink VRF
  const keyHash = process.env.KEY_HASH; // key hash for Chainlink VRF
  const gasLimit = 2500000; 

  const argumentsArray = [vrfCoordinatorV2Address, subId, keyHash, gasLimit ]
  const content = "module.exports = " + JSON.stringify(argumentsArray, null, 2) + ";";
  fs.writeFileSync("./arguments.js", content);
  console.log("arguments.js file generated successfully.");

  // Deploying OnePiecePersonalityDapp contract
  const OnePiecePersonalityDapp = await ethers.getContractFactory("OnePieceMint");

  console.log("Deploying OnePiecePersonalityDapp...");

  const onePiecePersonalityDapp = await OnePiecePersonalityDapp.deploy(
    vrfCoordinatorV2Address, 
    subId, 
    keyHash,
    gasLimit);

  console.log("OnePiecePersonalityDapp deployed to:", await onePiecePersonalityDapp.getAddress()); 

}

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

This script deploys a contract named One Piece Personality Dapp (`OnePieceMint` contract) using Hardhat. Here's what it does:

- Imports required modules such as ethers, fs, and dotenv.
- Loads environment variables from a .env file using dotenv.
- Defines the main function `main()` for deploying contracts.
- Gets the deployer's signer using ethers.
- Retrieves necessary parameters (VRF address, subscription ID, key hash, gas limit) from environment variables.
- Prepares an arguments array for contract deployment and saves it to a file named `arguments.js`. This file helps us pass the arguments to our `OnePieceMint` contract. So that we don’t get confused.
- Deploys the `OnePiecePersonalityDapp` contract with provided arguments.
- Logs the address where the contract is deployed.
- Handles errors and exits the script with appropriate status codes.

## Update `hardhat.config.js`

We need to add the wallet and network details so Hardhat knows who is deploying on which network. Open `hardhat.config.js` and replace the existing content with the following:

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

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

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

module.exports = {
  networks: {
    mumbai: {
      url: "https://polygon-mumbai-pokt.nodies.app",
      accounts: privateKey(),
    },
    sepolia: {
      url: "https://eth-sepolia.public.blastapi.io",
      accounts: privateKey(),
    },
    arbitrum_sepolia: {
      url: "https://sepolia-rollup.arbitrum.io/rpc",
      accounts: privateKey(),
    }
  },
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 1000,
      },
    },
  },  etherscan: {
    apiKey: process.env.API_KEY, 
  },
};
```

## Deploy the contracts

Now we are ready to compile the contracts using the following command:

```
npx hardhat run scripts/deploy.js --network arbitrum_sepolia
```

You will see an output like this:

![deploy-1 (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Deploy%20Smart%20Contracts/deploy-1_(1).webp?raw=true)

You will notice that the new folder named `artifacts` is created in `one-piece-dapp`. We need the JSON files of our contracts created on the front end.

You will also notice that while deploying the contract, a new file `arguments.js` file is created. This file is used to pass the arguments to the `OnePieceMint` contract.

## Verify the contract

Now we need to verify the contract. Why do we need to verify? We are importing multiple contracts in our `OnePieceMint` contract and they are importing more contracts. In the future, they might be changed. Verifying the contract makes us deploy those contracts with our contracts. Here’s how you can do this. 

1. First, copy the contract address from your deployment output.
    
    ![deploy-output (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Deploy%20Smart%20Contracts/deploy-output_(1).webp?raw=true)
    
2. Run the following command and replace `<your-contract-address>` with your contract address. 

```
npx hardhat verify --constructor-args arguments.js <your-contract-address> --network arbitrum_sepolia
```

You will get the following output after deploying the contract.

![deploy-2 (2).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Deploy%20Smart%20Contracts/deploy-2_(2).webp?raw=true)

## Add consumers to Chainlink

Next, we will follow the following steps to add consumers to Chainlink:

- Copy the contract addresses of the contract you have just deployed.
- Head over to [https://vrf.chain.link/arbitrum-sepolia](https://vrf.chain.link/arbitrum-sepolia).
- Click on the subscription ID you are using.
- Click on “Add consumer”.
- Paste your contract address.
- Click on “Add consumer”.
- Click on “Confirm” to approve the transaction.

See how I did it in the following gif:

![Frame 3560365 (29).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Deploy%20Smart%20Contracts/Frame_3560365_(29).webp?raw=true)

Repeat the same process for the other contract address.

And with this, we are ready to move on to the next step!

## Wrap up

In this lesson, you learned how to compile and deploy smart contracts using the Hardhat framework. You also created a deployment script for compiling the Solidity smart contracts, `OnePieceMint`, and verified the contract.

We will work on the front end in the next lesson.



https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/3.%20Deploy%20Smart%20Contracts/1.%20Deploy%20Your%20One%20Piece%20Contract.md

Deploy Your One Piece Contract

# Set Up the Frontend Project

Welcome back! I’m so proud of you that you have so far and finally, you are at the last stage of the course where you will connect your dApp to the front end. 

## Set your project

Open your terminal and run the following commands. You can run the commands either inside the `one-piece-dapp` folder or outside of the folder.

```
git clone https://github.com/0xmetaschool/one-piece-frontend-boilerplate.git
cd one-piece-frontend-boilerplate
npm install
```

Now create `.env` file in the `one-piece-frontend-boilerplate` and paste the following content into it:

```
REACT_APP_CONTRACT_ADDRESS=<your-contract-address>
REACT_APP_SUBGRAPH_URL=<your-subgraph-url>
```

Replace `<your-contract-address>` with your contract address.

## Create subgraph

Now let’s create the subgraph using Graph Studio.

- Head over to [https://thegraph.com/studio/](https://thegraph.com/studio/).
- Connect your Metamask account and sign the transaction.
- Now verify your email to proceed
    
    ![Screen Recording 2024-03-11 at 5.07.02 PM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/Screen_Recording_2024-03-11_at_5.07.02_PM.webp?raw=true)
    
- Now click on “Create a subgraph”.
- Add the name and create it.
    
    ![Screen Recording 2024-03-11 at 5.08.25 PM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/Screen_Recording_2024-03-11_at_5.08.25_PM.webp?raw=true)
    

- Now scroll down and look at the right panel of your screen, you will see the set of commands. We need to run them.
    
    ![Frame 3560371 (3).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/Frame_3560371_(3).webp?raw=true)
    

- **Important**: Please note that I’ll be running the commands shown to me according to my subgraph, you have to run according to yours. In the steps below, I’ll help you with the inputs that the commands ask. So follow me and let’s go!

I’ll run the commands with you and guide you what steps you have to follow. Ikuzou~

- First of all, install the CLI. You can either use npm or yarn. I used yarn, so go to this [link](https://classic.yarnpkg.com/lang/en/docs/install/#mac-stable) if you want to install yarn.
    
    ```
    npm install -g @graphprotocol/graph-cli
    // or run the following
    yarn global add @graphprotocol/graph-cli
    ```
    
- Next, is the `init` command. The command is designed according to whatever your subgraph name is defined.
    
    ```
    graph init --studio one-piece
    ```
    
    - Select “ethereum” for Protocol.
    - Hit the Enter button for the next two options.
    - Find the “Arbitrum Sepolia” Network.
    - Paste your contract address.
    - Hit Enter for the Start Block option.
    - Give `OnePieceMint` for the contract name. If your smart contract name differs then provide that.
    - Select `Y` for the option “Index contract events as entities”.
    - Select `n` for the next option.
    - Here’s the final output of this command:
        
        ![Frame 3560382.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/Frame_3560382.webp?raw=true)
        
- Next is authenticate command, for me it shows `graph auth --studio 674cfa58b1f064d1b11f2ab99ff959db`. But for you, it’ll be different so copy yours and run it.
- Move to the directory we created using `init` command by `cd one-piece`.
- Run `graph codegen && graph build` to generate the code and build the graph.
- Finally, deploy your graph. For me the command is `graph deploy --studio one-piece`. But for you, it’ll be different so copy yours and run it. Provide version when prompted. Since it’s our first deployment version you can use `v0.0.1`.
    
    ![Frame 3560382 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/Frame_3560382_(1).webp?raw=true)
    
    - **Note**: If you are deploying it again, make sure to update the version number otherwise you’ll receive an error.
- As an output, you will see a URL at the end, replace `<your-subgraph-url>` in your `.env` file with it.
    
    ![Frame 3560382 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/Frame_3560382_(2).webp?raw=true)
    

## Run the dapp

Now it’s time to finally run it. Open the terminal or use the existing one. First move to the previous directory and then run the dapp:

```
cd ../ 
npm start
```

## Interact with dapp

And you can experience interacting with your dApp. And yes, Zoro is my favv characterrrr!! What about you?

![interact.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/one-piece-dapp/Set%20Up%20the%20Frontend%20Project/interact.webp?raw=true)

## Wrap up

In conclusion, this lesson guided you through the process of setting up the frontend of your dApp, creating a subgraph using Graph Studio, and deploying your graph. This is a crucial step in connecting your dApp with the front end. Great job on completing this complex task. By running the command `npm start` in the terminal, we can now interact with our dApp. This concludes our lesson.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/4.%20Add%20DApp%E2%80%99s%20Frontend/Setup%20the%20Frontend.md

Set Up the Frontend Project

# Let’s Wrap It Up

Alright, let's wrap it up and celebrate your incredible journey! 🎉 It's time to take a moment and reflect on everything you've learned in this course. Get ready for a quick recap that will leave you feeling accomplished and ready to conquer the world! 

## Setting up the Development Environment

You set up the development environment and installed all the necessary dependencies. You learned how to:

- Set up the testnet environment
- Connect your Metamask wallet
- Fetch fake ETH
- Set Hardhat project
- Secure private data
- Create an API key for ABIScan
- Set up Chainlink

## Writing smart contracts

You wrote `OnePieceMint.sol` which allows the owner to mint non-fungible tokens representing the five characters of Luffy crew. You used Chainlink's VRF service to generate random numbers and then minted an NFT for the user with the randomly assigned character.

## Compiling the contracts

You wrote the deploy scripts and updated the necessary files to compile the contracts.

## Adding frontend

You added frontend to your dApp, learned to integrate the frontend with the backend (smart contracts), and interacted with it.

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the knowledge to create a dApp.

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20One%20Piece%20Personality%20DApp%20using%20Solidity/5.%20Wrap%20Up/Let%E2%80%99s%20Wrap%20It%20Up.md

Let’s Wrap It Up

Build a One Piece Personality dApp With Solidity

Build a Hogwarts Sorting Hat dApp to elevate your dApp building skills with a touch of nostalgia. In this one-of-its-kind Metaschool course, you will get to build a Sorting Hat dApp and make it choose one of the four Hogwarts houses for you. Then, you will learn to code the logic in smart contracts, deploy it, and integrate it into a React frontend to interact with it. So get ready to relive your fond childhood memories.

# What Are We Building Today

gm everyone ☀️ We are very excited to bring the course where you will build a project in Solidity to help you become a Solidity and dApp creation master.

So what are we building today? We will be building our very own Hogwarts Sorting Hat dApp. Yes, inspired by the Harry Potter concept, we will sort you and your friends to their respective houses. This project is important as it equips you with necessary knowledge to build a dApp in the web3 ecosystem.


Let’s look at how you will be interacting with the dApp by the end of the course. You can also try using it live [here](https://hogwarts-app.vercel.app/). We will be using Polygon Mumbai network to connect to the app. In case you are going to try out the demo application.

![Frame 3560365 (28).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/What%20Are%20We%20Building%20Today/Frame_3560365_(28).webp?raw=true)

Why Hogwarts Sorting dApp? You can unlock your wizardry in Solidity and master web3 dApp development with our Hogwarts Sorting dApp course. You will learn the magic behind smart contracts while creating a fun and interactive project, ensuring you not only ace Solidity but also become a wizard in the world of decentralized applications.

Not only this, Solidity is most popular language of web3 and in demand too! There are ~200,000 Solidity developers and their maximum yearly salary is $250k. On average, 128 new jobs for Solidity developers are posted every month.

## Course overview

We will:

1. Set up basic project using Hardhat
2. Learn how to code Hogwarts randomness in Solidity
3. Deploy the smart contracts on Polygon Amoy Testnet
4. Set up React frontend and integrate it with the Solidity smart contract (backend)
5. Deploy the final dApp and interact with it

- **Keep your momentum going! In 3rd to 11th lesson, we’ll teach the most exciting part of the course which I can’t wait to tell you about.**

## Who exactly should take this course?

This course is for intermediate web3 developers who want to up skill their dApp building and Solidity command. You should have a basic knowledge of blockchain, [consensus mechanism](https://metaschool.so/articles/consensus-mechanism-meaning/), Solidity Programming language, and frontend technologies because in this course we will focus more on building and deploying our dApp. Don’t worry! If you don’t know the basics we got you covered, you can always reach out to us for any help.

## Prerequisites

- MetaMask extension installed in your browser ([Chrome extension link](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn))

> **Note:** Please refer to [this course](https://metaschool.so/courses/understand-and-setup-metamask-account) to setup your MetaMask if you still hasn’t. Come back to this course after you have set it up.

## Proof of completion

If you complete this course with me today, you will be getting a special NFT, a utility token, which will unlock many more opportunities for you on the Metaschool platform. Here is how the NFT looks like.

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


Now before we move forward, let’s set some house rules first.
1. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/hogwarts-dapp-twitter) and [LinkedIn](https://bit.ly/hogwarts-dapp-linkedin), it would be a great support.  🫣
4. Stay happy and positive!


- **Not only this, you will receive double XP, if you complete the course within 3 days. Find the quest on the right side of your screen.**

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


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Building%20Today.md

# Set Up Your Project

Greetings folks! Let’s dive right into setting up our project. Let’s go!!

## What is a development environment?

You now need a super cool environment to run your code in and you need to set it up!

For this tutorial, you will use MetaMask wallet, Polygon faucet, PolygonScan API, Chainlink, and Hardhat, and IDE like Visual Studio for compiling and deploying your code. Don’t worry, setting them up is easy and you will do it in no time!

## MetaMask

If you do not have MetaMask extension, you can install in your browser using [Chrome extension link](https://chrome.google.com/webstore/detail/metamask/nkbihfbeogaeaoehlefnkodbefgpgknn).

### Setting up the testnet environment

Now we need to set the testnet network so we can deploy our dapp on it. Complete the following steps to set it up:

- Head over to [https://metaschool.so/rpc/amoy](https://metaschool.so/rpc/amoy).
- Click on first “Add to Metamask” button.
  ![add-metamask.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Set%20Up%20Your%20Project/add-metamask.webp?raw=true)
- Click on “Approve” and then “Switch network”.

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

![addtometamask.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Set%20Up%20Your%20Project/addtometamask.webp?raw=true)

### Get some fake MATIC $$ 🤑

Now its time to get some money!

- Copy your account address from MetaMask.
- Head over to [https://faucet.polygon.technology/](https://faucet.polygon.technology/)
- Connect your discord for verification
- Select Polygon PoS(Amoy) as the network
- Make sure MATIC is selected as the token
- Paste your wallet address
- Click on “Submit”
- You will receive some fake MATIC

## Set Hardhat project

Open your terminal and run the following commands:

```
mkdir hogwarts-dapp
cd hogwarts-dapp
npm install --save-dev hardhat --force
```

Initialize a new Hardhat project using the following command:

```
npx hardhat init
```

You will see an output like shown below. Select Javascript project and hit Enter for all other options:

![Frame 3560364 (40).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Set%20Up%20Your%20Project/Frame_3560364_(40).webp?raw=true>)

Install all dependencies using the following command:

```
npm install --force
npm install hardhat @nomiclabs/hardhat-ethers @nomiclabs/hardhat-etherscan dotenv ethers --force
```

Your project directory now looks like this:

![Frame 3560365 (37).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Set%20Up%20Your%20Project/Frame_3560365_(37).webp?raw=true>)

## Wrap up

In this lesson, we have got some fake MATICs and set up our Hardhat project and installed necessary dependencies. Next, we will learn to secure necessary data.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/1.%20Let%E2%80%99s%20Get%20Started/2.%20Set%20Up%20Your%20Project.md

# Secure Your Data

Greetings folks! We have set up our project. Now we need some private data to deploy the contracts so let’s see how we can secure that. And we will also fetch some API keys and other data that will be required later. Let’s go!!

## Why there’s a need to secure data?

While writing and deploying your contract you sign off each contract with your private key of MetaMask wallet to tell the blockchain that you are a legit person creating a real transaction. Now if that private key is made visible, the hacker can gain access to your account and then the rest will be history. In order to avoid this issue. Let’s do the following.

## Create `.env` file

Let’s use `.env` file to store all the secrets and important keys related to your project so we can access this data whenever and wherever.

Create a file named `.env` in the folder `hogwarts-dapp` and copy the following data in the file:

```
PRIVATE_KEY="YOUR_METAMASK_PRIVATE_KEY"
POLYGONSCAN_API_KEY="YOUR_POLYGONSCAN_API_KEY"
VRFaddress="YOUR_VRF_COORDINATOR_ADDRESS"
SubId="YOUR_SUBSCRIPTION_ID"
keyHash="YOUR_KEY_HASH"
gasLimit="50000"
```

My `.env` file looks like this:

![Frame 3560364 (39).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/Frame_3560364_(39).webp?raw=true>)

- If `gitignore` file is not created then create a file named `.gitignore` file in the folder `hogwarts-dapp`. In the `gitignore` file, we’ll simply write `.env`, so that it tells git to ignore that file from future commits. And we do not accidentally push our secrets data to public.

## 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. Now if that private key is made visible, the hackers can gain access to your account and then the rest will be history.

1. Open the MetaMask extension to find your private key.
2. Click on Account.
3. Click on 3 dots on right side and go to “Account Details”.
4. Click on “Show private key”.
5. Enter MetaMask password.
6. Copy your private key.
7. Replace `YOUR_METAMASK_PRIVATE_KEY` with your private key in the `.env` file.

![Frame 3560365 (23).gif](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/Frame_3560365_(23).webp?raw=true>)

## PolygonScan API

Now you need to have an API so follow the steps given below:

- Head over to [https://polygonscan.com/login](https://polygonscan.com/login).
- Login or signup to PolygonScan.
- Go to “API-KEYs” on the left navigation bar.
- If you don’t have an API key. Generate one by clicking on “+Add” button.
- After generating the key, copy your Api-Key Token.
- Replace `YOUR_POLYGONSCAN_API_KEY` with yours in the `.env` file.
  ![Frame 3560365 (32).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/Frame_3560365_(32).webp?raw=true>)

## Chainlink

Follow the steps given below:

- Head over to [https://vrf.chain.link/polygon-amoy](https://vrf.chain.link/polygon-amoy).
- Click on “Connect wallet” and connect your MetaMask wallet.
  ![connect-vrf.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/connect-vrf.webp?raw=true)
- Copy “VRF Coordinator” and replace `YOUR_VRF_COORDINATOR_ADDRESS` with yours in the `.env` file. I have pointed the address in the following image for your ease.

![vrf-cordinator-copy.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/vrf-cordinator-copy.webp?raw=true)

- Copy “Key Hash” address and replace `YOUR_KEY_HASH` with yours in the `.env` file. I have pointed the hash in the following image for your ease.

![key-hash-copy.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/key-hash-copy.webp?raw=true)

### Create subscription

- Next, click on create subscription:
  - Click on create subscription.
  - Sign the transaction.
  - Confirm the transaction.
  - Wait for few seconds. Click on “Add Funds” pop up but move to home page without adding any link.
    ![Frame 3560365 (25).gif](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/Frame_3560365_(25).webp?raw=true>)
- Now go back to “Home”. Under “My Subscriptions”, you’ll find the subscription you created just yet. Click on it and copy the subscription ID.
- Replace `YOUR_SUBSCRIPTION_ID` with your ID in the `.env` file.
  ![Frame 3560365 (27).gif](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Secure%20Your%20Data/Frame_3560365_(27).webp?raw=true>)

Awesome, setting all of this was a lot but you did great! Now, you are all set up to start writing the code!

## Wrap up

In this lesson, we have learned how to secure our data using `.env` file. Then we fetched the required data and utilized MetaMask wallet, Polygon faucet, PolygonScan API, and Chainlink for that.

Now that our development environment is ready, we can move on to building our dApp. Stay tuned for the next lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/1.%20Let%E2%80%99s%20Get%20Started/3.%20Secure%20Your%20Data.md

# Create Hogwarts Contract

Welcome back! So we are done with setting up our project. Now it’s time to code!! Wohoo, so let’s start coding!

## Create a file

Navigate to `contracts` directory. Delete existing `Lock.sol` as we do not need it.

Create a new Solidity file called `HogwartsNFT.sol` in the `contracts` directory:

![Frame 3560364 (34).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Create%20Hogwarts%20Contract/Frame_3560364_(34).webp?raw=true>)

## Write code

We will write that does the following:

- Allows the owner to mint non-fungible tokens representing the four Hogwarts houses.
- Store NFTs on IPFS and associated them with a specific house.
- Make the tokens soulbound within the Hogwarts context.

So why wait, let’s go!

First are the license and import statements (ignore any red lines or warnings):

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
```

- These lines provide SPDX license information and specify the Solidity version to be used (0.8.8).
- These import statements bring in several pre-built Solidity smart contracts from external libraries:
  - `ERC721URIStorage.sol` is a contract that extends the ERC721 standard by adding support for storing metadata associated with each token, such as an image or description.
  - `Ownable.sol` is a contract that provides a basic access control mechanism, allowing the contract owner to restrict certain functions to themselves.
  - `ERC721.sol` is a contract that provides a basic implementation of ERC721 token.

```
contract HogwartsNFT is ERC721URIStorage, Ownable {
```

- This line defines a new Solidity contract named `HogwartsNFT`.
- It inherits from two other contracts, `ERC721URIStorage` and `Ownable`.
- `ERC721URIStorage` is likely an ERC-721 token standard with URI storage for NFT metadata, and `Ownable` provides ownership functionality.

```
mapping(uint256 => address) public s_requestIdToSender;
mapping(address => uint256) public s_addressToHouse;
mapping(address => bool) public hasMinted;
mapping(address => string) public s_addressToName;

uint256 private s_tokenCounter;
```

These lines declare several state variables:

- `s_requestIdToSender`: A mapping that associates a request ID (represented as a `uint256`) with the address that made that request.
- `s_addressToHouse`: A mapping that associates an address with the index of the Hogwarts house they received.
- `hasMinted`: A mapping that tracks whether an address has already minted an NFT.
- `s_addressToName`: A mapping to associate name with address.
- `s_tokenCounter`: A private variable to keep track of the number of NFTs minted.

```
string[] internal houseTokenURIs = [
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Gryffindor.json",
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Hufflepuff.json",
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Ravenclaw.json",
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Slytherin.json"
    ];
```

- It declares an internal array called `houseTokenURIs`, which contains strings representing the URIs for the token metadata of the four Hogwarts houses (Gryffindor, Hufflepuff, Ravenclaw, Slytherin). These URIs likely point to JSON files on IPFS.
- You can even upload your own assets on IPFS using Pinata or NFTstorage and replace the IPFS links accordingly.

```
event NftMinted(uint256 house, address minter, string name);
```

- This line defines an event called `NftMinted`, which will be called when an NFT is minted.
- It includes three parameters: the `house` (represented as a `uint256`), `minter` address, and the `name` the user will provide.

```
constructor() ERC721("Hogwarts NFT", "HP") {
    s_tokenCounter = 0;
}
```

- This is the constructor for the contract. It sets the initial state by initializing `s_tokenCounter` to 0 and also calls the constructor of the parent contract `ERC721` with the name "Hogwarts NFT" and symbol "HP."

```
function hasMintedNFT(address _user) public view returns (bool) {
    return hasMinted[_user];
}
```

- This is a public view read only function named `hasMintedNFT`.
- It allows anyone to check whether a specific address `_user` has already minted an NFT.
- It returns a boolean indicating whether the address has minted or not.

```
function getHouseIndex(address _user) public view returns (uint256) {
    return s_addressToHouse[_user];
}
```

- This is another public view function named `getHouseIndex`.
- It allows anyone to query the index of the Hogwarts house associated with a specific address `_user`. It returns a `uint256` representing the index.

```

function mintNFT(address recipient, uint256 house, string memory name) external onlyOwner {
        require(!hasMinted[recipient], "You have already minted your house NFT"); // Ensure the address has not minted before

        uint256 tokenId = s_tokenCounter;
        _safeMint(recipient, tokenId);
        _setTokenURI(tokenId, houseTokenURIs[house]);

        s_addressToHouse[recipient] = house; //map house to address
        s_addressToName[recipient] = name; // map name to address

        s_tokenCounter += 1;
        hasMinted[recipient] = true; // Mark the address as having minted an NFT

        emit NftMinted(house, recipient, name);
    }
```

This is a public function named `mintNFT`, which allows the contract owner (the onlyOwner modifier ensures this) to mint NFTs for users based on their specified recipient address, house index, and name. It performs several actions:

- `require(!hasMinted[recipient], "You have already minted your house NFT");`: This line uses a `require` statement to ensure that the recipient (address) has not already minted an NFT. If the recipient has already minted one, the function will revert with the specified error message.
- `uint256 tokenId = s_tokenCounter;`: This line initializes a variable `tokenId` with the current value of `s_tokenCounter`. This variable will represent the unique identifier for the newly minted NFT.
- `_safeMint(recipient, tokenId);`: This line calls the `_safeMint` function inherited from the ERC721 contract to mint a new NFT for the `recipient` with the specified `tokenId`.
- `_setTokenURI(tokenId, houseTokenURIs[house]);`: This line calls the `_setTokenURI` function to associate the metadata URI for the newly minted NFT with the specified `tokenId` and `house`. The metadata URI is fetched from the `houseTokenURIs` array based on the provided `house` index.
- `s_addressToHouse[recipient] = house;`: This line updates the `s_addressToHouse` mapping, associating the `recipient`'s address with the `house` index. This information indicates which house the NFT represents.
- `s_addressToName[recipient] = name;`: This line updates the `s_addressToName` mapping, associating the `recipient`'s address with the provided `name`. This allows associating a name with the NFT owner's address.
- `s_tokenCounter += 1;`: This line increments the `s_tokenCounter` by 1, ensuring that the next minted NFT will have a unique token ID.
- `hasMinted[recipient] = true;`: This line marks the `recipient`'s address as having minted an NFT by setting the corresponding value in the `hasMinted` mapping to `true`.
- `emit NftMinted(house, recipient, name);`: Finally, this line emits the `NftMinted` event with information about the `house`, `recipient` address, and `name` of the minted NFT. This event allows external parties to listen for NFT minting events and react accordingly.

```
function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        require(from == address(0) || to == address(0), "Err! This is not allowed in Hogwarts");
    }
}
```

- This function overrides the `_beforeTokenTransfer` function of the parent contract `ERC721`.
- It enforces a custom transfer condition where transfers are only allowed from or to the zero address (`address(0)`), indicating that the tokens are **soulbound** within the Hogwarts context.
- If this condition is not met, it reverts the transaction.

## Complete code

The complete code for the `HogwartsNFT.sol` is:

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

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";

contract HogwartsNFT is ERC721URIStorage, Ownable {
    mapping(uint256 => address) public s_requestIdToSender;
    mapping(address => uint256) public s_addressToHouse;
    mapping(address => bool) public hasMinted;
    mapping(address => string) public s_addressToName;

    uint256 private s_tokenCounter;

    string[] internal houseTokenURIs = [
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Gryffindor.json",
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Hufflepuff.json",
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Ravenclaw.json",
        "ipfs://QmXja2QBKsNW9qnw9kKfcm25rJTomwAVJUrXekYFJnVwbg/Slytherin.json"
    ];

    event NftMinted(uint256 house, address minter, string name);

    constructor() ERC721("Hogwarts NFT", "HP") {
        s_tokenCounter = 0;
    }

    // Read-only function to check whether a user has minted an NFT
    function hasMintedNFT(address _user) public view returns (bool) {
        return hasMinted[_user];
    }

    // Read-only function to get the house index mapped to the user
    function getHouseIndex(address _user) public view returns (uint256) {
        return s_addressToHouse[_user];
    }

    //Function to mint NFT according to the house index
    function mintNFT(address recipient, uint256 house, string memory name) external onlyOwner {
        require(!hasMinted[recipient], "You have already minted your house NFT");

        uint256 tokenId = s_tokenCounter;
        _safeMint(recipient, tokenId);
        _setTokenURI(tokenId, houseTokenURIs[house]);

        s_addressToHouse[recipient] = house;
        s_addressToName[recipient] = name;

        s_tokenCounter += 1;
        hasMinted[recipient] = true;

        emit NftMinted(house, recipient, name);
    }


    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        require(from == address(0) || to == address(0), "Err! This is not allowed in Hogwarts");
    }

}
```

## Wrap up

In this lesson, we learned how to create a new Solidity contract, import existing Solidity smart contracts, and use OpenZeppelin and Chainlink libraries. We created a contract called `HogwartsNFT.sol` that allows the owner to mint non-fungible tokens representing the four Hogwarts houses. The NFTs are stored on IPFS and are associated with a specific house. The contract also enforces a custom transfer condition where transfers are only allowed from or to the zero address, indicating that the tokens are soulbound within the Hogwarts context.

In the next lesson, we will write the logic of our application. Stay tuned!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/2.%20Build%20Hogwarts%20Contract/1.Create%20Hogwarts%20Contract.md

Create Hogwarts Contract

# Create House Assignment Contract

Welcome back! So we are done with writing our code for Hogwarts contract. Now it’s time to code the house assignment part!! Wohoo, so let’s start coding!

## Create a file

Create a new Solidity file called `RandomHouseAssignment.sol` in the `contracts` directory:

![Frame 3560364 (35).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Create%20House%20Assignment%20Contract/Frame_3560364_(35).webp?raw=true>)

## Write code

Let’s write the code

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

- These lines provide SPDX license information and specify the Solidity version to be used (0.8.8).

```
import "./HogwartsNFT.sol";
import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";
```

- These lines import external contracts and interfaces:
    - `HogwartsNFT.sol`: Imports the `HogwartsNFT` contract, which we wrote in previous lesson.
    - `VRFCoordinatorV2Interface.sol`: Imports an interface from Chainlink VRF (Verifiable Random Function) for version 2 of the VRF coordinator.
    - `VRFConsumerBaseV2Plus.sol`: Imports a contract from Chainlink that helps interact with the Chainlink VRF service.

```
contract RandomHouseAssignment is VRFConsumerBaseV2Plus
```

- This line defines a new Solidity contract named `RandomHouseAssignment`, which inherits from `VRFConsumerBaseV2Plus`. This contract will be responsible for randomly assigning Hogwarts houses to users.

```
  HogwartsNFT public nftContract;
    uint256 private s_subscriptionId; // Changed to uint256 as per VRF 2.5
    bytes32 private i_keyHash; 
    uint32 public callbackGasLimit = 250000;
    mapping(uint256 => address) private s_requestIdToSender;
    mapping(address => string) private s_nameToSender;
```

- These lines declare several state variables for the `RandomHouseAssignment` contract:
    - `nftContract`: An instance of the `HogwartsNFT` contract (we declared in the previous lesson), representing the NFT contract where Hogwarts-themed NFTs are minted.
    - `i_vrfCoordinator`: An interface to the Chainlink VRF coordinator.
    - `i_subscriptionId`: A subscription ID obtained from Chainlink's VRF service.
    - `i_keyHash`: A key hash used for generating random numbers through Chainlink's VRF service.
    - `i_callbackGasLimit`: The gas limit for the callback function called by Chainlink's VRF service.
    - `s_requestIdToSender`: A mapping that associates a request ID with the address of the sender who made the request.
    - `s_nameToSender`: A private mapping that associates sender addresses with names.

```
 event NftRequested(uint256 indexed requestId, address requester);
```

- This line defines an event named `NftRequested`.
- This event will be emitted when a user requests a Hogwarts-themed NFT.
- It includes the `requestId` and `requester` address as indexed parameters for easy retrieval.

```
constructor(
        address _nftContract,
        uint256 subscriptionId,
        bytes32 keyHash,
        uint32 gasLimit
    ) VRFConsumerBaseV2Plus(0x9DdfaCa8183c41ad55329BdeeD9F6A8d53168B1B) { // Replace with actual VRF Coordinator address
        nftContract = HogwartsNFT(_nftContract);
        s_subscriptionId = subscriptionId;
        i_keyHash = keyHash;
        callbackGasLimit = gasLimit;
    }
```

- This is the constructor for the `RandomHouseAssignment` contract. It initializes the contract with various parameters:
    - `_nftContract`: The address of the `HogwartsNFT` contract.
    - `vrfCoordinatorV2Address`: The address of the Chainlink VRF coordinator.
    - `subId`: The subscription ID for Chainlink's VRF service.
    - `keyHash`: The key hash for generating random numbers.
    - `callbackGasLimit`: The gas limit for the callback function.
- In the constructor, the state variables are initialized.
- It also calls the constructor of the parent contract `VRFConsumerBaseV2Plus` with the `vrfCoordinatorV2Address` parameter.

```
function requestNFT(string memory name) public returns (uint256 requestId) {
        // Use the s_vrfCoordinator from VRFConsumerBaseV2Plus and the new request format for VRF 2.5
        requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: i_keyHash,
                subId: s_subscriptionId,
                requestConfirmations: 3, // Minimum confirmations
                callbackGasLimit: callbackGasLimit,
                numWords: 1, // Request 1 random word
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({nativePayment: false}) // Set nativePayment to false for LINK payment
                )
            })
        );

        s_requestIdToSender[requestId] = msg.sender;
        s_nameToSender[msg.sender] = name;
        emit NftRequested(requestId, msg.sender);
    }
```

- `function requestNFT(string memory name) public {`: This line declares a public function named `requestNFT` that takes a single parameter `name` of type `string` stored in memory. This parameter represents the name associated with the NFT to be minted. It allows a user to request a Hogwarts-themed NFT.
- `uint256 requestId = i_vrfCoordinator.requestRandomWords(`: This line initiates a request to the Chainlink VRF service to generate random words. It assigns the unique `requestId` generated for this request to a local variable named `requestId`. The parameters for this request are as follows:
    - `i_keyHash`: The key hash used to verify randomness.
    - `i_subscriptionId`: The subscription ID used with Chainlink VRF.
    - `3`: The number of random words to request (in this case, 3 words).
    - `i_callbackGasLimit`: The gas limit for the callback function.
    - `1`: A "userProvidedSeed" parameter, which is set to 1 in this case (it can be any value).
- `s_requestIdToSender[requestId] = msg.sender;`: This line records the relationship between the `requestId` and the sender's address (`msg.sender`) in the `s_requestIdToSender` mapping. This mapping is used to associate each request with the address that initiated it.
- `s_nameToSender[msg.sender] = name;`: This line associates the sender's address (`msg.sender`) with the provided `name` parameter in the `s_nameToSender` mapping. This is done to store the name associated with the NFT to be minted.
- `emit NftRequested(requestId, msg.sender);`: This line emits an event named `NftRequested` to log that a request for an NFT has been made. It includes two parameters:
    - `requestId`: The unique identifier for the request.
    - `msg.sender`: The address of the sender who initiated the request.

```
function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal override {
        address nftOwner = s_requestIdToSender[requestId];
        string memory name = s_nameToSender[nftOwner];
        uint256 house = randomWords[0] % 4;
        nftContract.mintNFT(nftOwner, house, name);
    }
```

- This function, `fulfillRandomWords`, is an internal override that handles the fulfillment of random words generated by Chainlink's VRF service. It does the following:
    - Retrieves the `nftOwner` address from `s_requestIdToSender` using the `requestId`.
    - `string memory name = s_nameToSender[nftOwner];`: Here, the function retrieves the name associated with the NFT owner (the sender's address) from the `s_nameToSender` mapping. This is the name that was provided when making the request.
    - Calculates a random `house` index based on the first random word.
    - `nftContract.mintNFT(nftOwner, house, name);`: Finally, this line calls the `mintNFT` function of the `nftContract` (HogwartsNFT contract) to mint a new NFT. It specifies the following parameters:
        - `nftOwner`: The address of the NFT owner (the requester).
        - `house`: The randomly determined house (0, 1, 2, or 3) for the NFT.
        - `name`: The name associated with the NFT owner, which will be used as part of the NFT's metadata.

## Complete code

The complete code for `RandomHouseAssignment.sol` is:

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

import "./HogwartsNFT.sol";
import {VRFConsumerBaseV2Plus} from "@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol";
import {VRFV2PlusClient} from "@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol";

contract RandomHouseAssignment is VRFConsumerBaseV2Plus {
    HogwartsNFT public nftContract;
    uint256 private s_subscriptionId; // Changed to uint256 as per VRF 2.5
    bytes32 private i_keyHash; 
    uint32 public callbackGasLimit = 250000;
    mapping(uint256 => address) private s_requestIdToSender;
    mapping(address => string) private s_nameToSender;

    event NftRequested(uint256 indexed requestId, address requester);

    constructor(
        address _nftContract,
        uint256 subscriptionId,
        bytes32 keyHash,
        uint32 gasLimit
    ) VRFConsumerBaseV2Plus(0x9DdfaCa8183c41ad55329BdeeD9F6A8d53168B1B) { // Replace with actual VRF Coordinator address
        nftContract = HogwartsNFT(_nftContract);
        s_subscriptionId = subscriptionId;
        i_keyHash = keyHash;
        callbackGasLimit = gasLimit;
    }

    function requestNFT(string memory name) public returns (uint256 requestId) {
        // Use the s_vrfCoordinator from VRFConsumerBaseV2Plus and the new request format for VRF 2.5
        requestId = s_vrfCoordinator.requestRandomWords(
            VRFV2PlusClient.RandomWordsRequest({
                keyHash: i_keyHash,
                subId: s_subscriptionId,
                requestConfirmations: 3, // Minimum confirmations
                callbackGasLimit: callbackGasLimit,
                numWords: 1, // Request 1 random word
                extraArgs: VRFV2PlusClient._argsToBytes(
                    VRFV2PlusClient.ExtraArgsV1({nativePayment: false}) // Set nativePayment to false for LINK payment
                )
            })
        );

        s_requestIdToSender[requestId] = msg.sender;
        s_nameToSender[msg.sender] = name;
        emit NftRequested(requestId, msg.sender);
    }

    function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal override {
        address nftOwner = s_requestIdToSender[requestId];
        string memory name = s_nameToSender[nftOwner];
        uint256 house = randomWords[0] % 4;
        nftContract.mintNFT(nftOwner, house, name);
    }
}

```

## Wrap up

In this lesson, we learned how to code the house assignment part of the Hogwarts contract. We created a new Solidity file called `RandomHouseAssignment.sol` and wrote the necessary code to randomly assign Hogwarts houses to users. We used Chainlink's VRF service to generate random numbers, and then minted an NFT for the user with the randomly assigned house. With this, we have completed the code for the Hogwarts contract.

In the next lesson, we will finally deploy it, Wohoo, let’s go!

**Assignment Title:** What logic have we used to select houses for the user?

**Assignment:** Let us know.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/2.%20Build%20Hogwarts%20Contract/2.%20Create%20House%20Assignment%20Contract.md

Create House Assignment Contract

# Deploy Smart Contracts

Welcome back! You did great in the last lesson, coding all smart contracts. In this lesson, you will learn to compile and deploy your smart contracts. Let’s start this awesome journey!

We need a deployment script for compiling two Solidity smart contracts, `HogwartsNFT` and `RandomHouseAssignment`, using the Hardhat framework. 

Navigate to `scripts` folder and remove the existing content of `deploy.js`. Let’s write our new code in `deploy.js`.

## Write code

Let’s start writing code:

**Import Hardhat:**

```
const hre = require("hardhat");
```

- The script imports the Hardhat library to access Ethereum development tools and configurations.

**Environment Variables:**

```
const vrfCoordinatorV2Address = process.env.VRFaddress;
const subId = process.env.SubId;
const keyHash = process.env.keyHash;
const gasLimit = 2500000; // Set the gas limit you want to use
```

- The script reads environment variables for VRF (Verifiable Random Function) settings, such as the VRF coordinator's address, subscription ID, key hash, and gas limit. yes, it utilizes the

**Main Function:**

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

- The `main` function is defined, which will perform the deployment and ownership transfer of the contracts.

**Deploying Hogwarts NFT Contract:**

```
console.log("Deploying Hogwarts NFT Contract...");

  const HogwartsNFT = await hre.ethers.getContractFactory("HogwartsNFT");
  const hogwartsNFT = await HogwartsNFT.deploy();
```

- It logs a message indicating the deployment of the `Hogwarts NFT` contract.
- It uses Hardhat to create a factory for the `HogwartsNFT` contract and then deploys it.

**Waiting for Confirmation Blocks:**

```
let currentBlock = await hre.ethers.provider.getBlockNumber();
  while (currentBlock + 5 > (await hre.ethers.provider.getBlockNumber())) {}

```

- It retrieves the current block number and waits for 5 additional blocks to be mined before proceeding. This is often done to ensure that the contract deployment is confirmed on the  network.

**Getting the Contract Address:**

```
const hogwartsAddress = await hogwartsNFT.getAddress();
  console.log("Hogwarts NFT deployed to:", hogwartsAddress);

```

- It obtains the Ethereum address of the deployed `Hogwarts NFT` contract and logs it.

**Deploying Random House Assignment Contract:**

```
console.log("Deploying Random House Assignment Contract...");

  const RandomHouse = await hre.ethers.getContractFactory("RandomHouseAssignment");

  // Deploy with overrides: gasLimit as part of an object
  const randomHouse = await RandomHouse.deploy(
    hogwartsAddress,
    vrfCoordinatorV2Address,
    subId,
    keyHash,
    { gasLimit } // Correctly passing the overrides as an object
  );
```

- It logs a message indicating the deployment of the "Random House Assignment" contract.
- It uses Hardhat to create a factory for the "RandomHouseAssignment" contract and then deploys it, passing various parameters including the address of the "Hogwarts NFT" contract.

**Waiting for Confirmation Blocks (Again):**

```
while (currentBlock + 5 > (await hre.ethers.provider.getBlockNumber())) {}
```

- Similar to earlier, it waits for an additional 5 blocks to be mined after deploying the "Random House Assignment" contract.

**Getting the Contract Address (Again):**

```
 const randomAddress = await randomHouse.getAddress();
  console.log("Random House Assignment deployed to:", randomAddress);
```

- It obtains the Ethereum address of the deployed "Random House Assignment" contract and logs it.

**Transferring Ownership:**

```
await hogwartsNFT.transferOwnership(randomAddress);
  console.log("Ownership transferred");
}
```

- It transfers ownership of the "Hogwarts NFT" contract to the "Random House Assignment" contract. This step ensures that the "Random House Assignment" contract has control over the NFTs.

**Execute the Main Function:**

```
main().catch((error) => {
  console.error("Deployment error:", error);
  process.exit(1);
});
```

- Finally, the script calls the `main` function to execute the deployment and ownership transfer processes.

## Complete code

The complete code for `deploy.js`**:**

```
const hre = require("hardhat");

const vrfCoordinatorV2Address = process.env.VRFaddress;
const subId = process.env.SubId;
const keyHash = process.env.keyHash;
const gasLimit = 2500000; // Set the gas limit you want to use

async function main() {
  console.log("Deploying Hogwarts NFT Contract...");

  const HogwartsNFT = await hre.ethers.getContractFactory("HogwartsNFT");
  const hogwartsNFT = await HogwartsNFT.deploy();

  let currentBlock = await hre.ethers.provider.getBlockNumber();
  while (currentBlock + 5 > (await hre.ethers.provider.getBlockNumber())) {}

  const hogwartsAddress = await hogwartsNFT.getAddress();
  console.log("Hogwarts NFT deployed to:", hogwartsAddress);

  console.log("Deploying Random House Assignment Contract...");

  const RandomHouse = await hre.ethers.getContractFactory("RandomHouseAssignment");

  // Deploy with overrides: gasLimit as part of an object
  const randomHouse = await RandomHouse.deploy(
    hogwartsAddress,
    vrfCoordinatorV2Address,
    subId,
    keyHash,
    { gasLimit } // Correctly passing the overrides as an object
  );

  while (currentBlock + 5 > (await hre.ethers.provider.getBlockNumber())) {}

  const randomAddress = await randomHouse.getAddress();
  console.log("Random House Assignment deployed to:", randomAddress);

  // Transferring ownership
  await hogwartsNFT.transferOwnership(randomAddress);
  console.log("Ownership transferred");
}

main().catch((error) => {
  console.error("Deployment error:", error);
  process.exit(1);
});

```

## Update `hardhat.config.js`

We need to add the wallet and network details so hardhat knows who is deploying on which network. Open `hardhat.config.js` and replace the existing content with the following:

```
require('dotenv').config();
require("@nomicfoundation/hardhat-toolbox");

module.exports = {
  defaultNetwork: "polygon_mumbai",
  networks: {
    hardhat: {
    },
    polygon_mumbai: {
      url: "https://rpc-amoy.polygon.technology/",
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: process.env.POLYGONSCAN_API_KEY
  },
  solidity: {
    version: "0.8.20",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  },
}
```

## Deploy the contracts

Now we are ready to compile the contracts using the following command:

```
npx hardhat run scripts/deploy.js --network polygon_mumbai
```

You will see an output like this:

![Frame 3560364 (38).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Deploy%20Smart%20Contracts/Frame_3560364_(38).webp?raw=true)

You will also notice that the new folders named `artifacts` is created in `hogwarts-dapp`. We need the json files of our contracts created in frontend.

Navigate to `artifacts/contracts`, a folder for each contract you deployed will be create. Copy the `json files`. I have highlighted which json files you need to copy.

![Frame 3560365 (38).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Deploy%20Smart%20Contracts/Frame_3560365_(38).webp?raw=true)

## Add consumers to Chainlink

Next, we will follow the following steps to add consumer to Chainlink:

- Copy the contract addresses of the contract you have just deployed.
    
    ![Frame 3560364 (38) copy.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Deploy%20Smart%20Contracts/Frame_3560364_(38)_copy.webp?raw=true)
    
- Head over to [https://vrf.chain.link/mumbai](https://vrf.chain.link/mumbai).
- Click on the subscription ID you are using.
- Click on “Add consumer”.
- Paste your contract address.
- Click on “Add consumer”.
- Click on “Confirm” to approve the transaction.

See how I did it in the following gif:

![Frame 3560365 (29).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Deploy%20Smart%20Contracts/Frame_3560365_(29).webp?raw=true)

Repeat the same process for the other contract address.

And with this, we are ready to move on to the next step!

## Wrap up

In this lesson, you learned how to compile and deploy smart contracts using the Hardhat framework. You also created a deployment script for compiling two Solidity smart contracts, `HogwartsNFT` and `RandomHouseAssignment`, and transferred ownership of the `HogwartsNFT` contract to the `RandomHouseAssignment` contract.

We will work on frontend in the next lesson.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/3.%20Deploy%20Smart%20Contracts/1.%20Deploy%20Smart%20Contracts.md

Deploy Smart Contracts

# Setup the Frontend Project

Welcome back! I’m so proud of you that you have so far and finally you are at the last stage of the course where you will be connecting your dApp to the frontend.

## Set React project

Open your terminal and run the following commands. You can run the commands whether inside of the`hogwarts-dapp` folder or outside of the folder.

```
mkdir hogwarts-dapp-frontend
cd hogwarts-dapp-frontend
```

Initialize a new React project using the following command:

```
npx create-react-app .
```

Now, let’s install our dependencies:

```
npm install use-sound
npm install lottie-react
```

Let me also provide you with some assets which can make this frontend even more exciting:

- assets: [https://github.com/0xmetaschool/Learning-Projects/tree/main/assests_for_all/assests_for_hogwarts_app/assets](https://github.com/0xmetaschool/Learning-Projects/tree/main/assests_for_all/assests_for_hogwarts_app/assets)
- loaders: [https://github.com/0xmetaschool/Learning-Projects/tree/main/assests_for_all/assests_for_hogwarts_app/loaders](https://github.com/0xmetaschool/Learning-Projects/tree/main/assests_for_all/assests_for_hogwarts_app/loaders)
- sounds: [https://github.com/0xmetaschool/Learning-Projects/tree/main/assests_for_all/assests_for_hogwarts_app/sounds](https://github.com/0xmetaschool/Learning-Projects/tree/main/assests_for_all/assests_for_hogwarts_app/sounds)

Download them and add all these folders in `src`. Here’s how my project directory looks like:

![Frame 3560365 (34).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Setup%20the%20Frontend%20Project/Frame_3560365_(34).webp?raw=true>)

Now, we also need to add our code to our project, so why not just do it too right now! Create a folder named `artifacts` in `src`. Copy the json files for the two contracts we deployed in previous lesson and paste it to `src/artifacts`.

![Frame 3560365 (36).jpg](<https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/Setup%20the%20Frontend%20Project/Frame_3560365_(36).webp?raw=true>)

- **Note:** Make sure to move these folders with the file content to `/src` under the root folder.

## Add styling

Navigate to `App.css` and replace the existing code with the following:

```
@font-face {
  font-family: 'HPfont';
  src: url('./assets/HPfont.ttf') format('truetype');
}
@font-face {
  font-family: 'Potterfont';
  src: url('./assets/Potter.otf') format('truetype');
}

body {
  background-image : url(./assets/Old_paper.jpg);
}

.App {
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  margin-top: 50px;
}

h1 {
  font-family: 'HPfont', sans-serif;
  font-size: 85px;
  margin-bottom: 30px;
  text-align: center;
}

button {
  font-family: 'Hpfont', sans-serif;
  padding: 10px 20px;
  font-size: 35px;
  background-color: #1c1c1c;
  color: #fff;
  border: none;
  border-radius: 4px;
  cursor: pointer;
  margin-top: 20px;
}

button:hover {
  font-family: 'Hpfont', sans-serif;
  background-color: #333;
}

p {
  font-family: 'Potterfont', sans-serif;
  font-size: 60px;
  display: block;
  text-align: center;
  margin-bottom: 15px;
  margin-top: 15px;

}
.metamask-button {
  position: absolute;
  top: 10px;
  right: 50px;
}

.user-info {
  display: flex;
  align-items: center;
  background-color: #1a1a1a;  /* Dark background to match the theme */
  padding: 10px;
  border-radius: 8px;
}

.user-info span {
  top: 10px;
  right: 50px;
  color: #f4e9d8;  /* A parchment-like text color to contrast the dark background */
  margin-right: 15px;
  font-size: 18px;
}

.form {
  justify-content: center;
  align-items: baseline;
}

.input-box {
  font-family: 'Cinzel', serif;
  font-size: 20px;
  border: none;
  background-color: #f4e9d8;
  padding: 15px 20px;
  margin-bottom: 20px;
  outline: none;
}

.input-box:focus {
  border-bottom: 2px solid #000000;
}

.input-box::placeholder {
  color: #7f7f7f;
  opacity: 0.8;
}

.form-button {
  margin-left: 5px;
  align-self: flex-end; /* To align it with the bottom border of the input */
  font-size: 20px;  /* match the font-size with input-box */
  padding: 15px 20px;  /* match the padding with input-box */
}

.Hogwarts-logo {
  width: 10%; /* adjust to your preferred size */
  height: auto; /* maintains aspect ratio */
  display: block; /* centers the image horizontally */
  margin: 0 auto; /* centers the image horizontally */
}
```

Congrats you are all set to work on the codes now!!

## Wrap up

In this lesson, we learned how to set up a React project and install the necessary dependencies. We also added some exciting assets to our project directory to make the frontend more engaging. We created a folder for our contract artifacts and moved our smart contracts json files to our project directory. Lastly, we updated our styling. With all of this in place, we are now ready to start working on the frontend.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/4.%20Add%20dApp%E2%80%99s%20Frontend/1.%20Setup%20the%20Frontend%20Project.md

Setup the Frontend Project

# Let’s Implement the Basics

Welcome back, you awesome person! We are all set for writing code so in this lesson, we will implement the basic structure of the frontend to help you understand the structure of the code.

## Start coding

Navigate to `src/App.js` and remove the existing code as we will be writing our own.

Let’s first import the libraries and some of the assets we imported:

```
import React, { useState, useEffect } from "react";
import useSound from 'use-sound';
import Web3 from "web3";
import HogwartsNFT from "./artifacts/HogwartsNFT.json"; 
import RandomHouseAssignment from "./artifacts/RandomHouseAssignment.json"; 
import HogwartsLogo from "./assets/hogwarts_logo.png"; // import the image
import "./App.css";
import Lottie from "lottie-react";
import HPLoader from "./loaders/hpLoader.json"

//import audio
import gryffindorSound from "./sounds/gryffindor.mp3";
import hufflepuffSound from "./sounds/hufflepuff.mp3";
import ravenclawSound from "./sounds/ravenclaw.mp3";
import slytherinSound from "./sounds/slytherin.mp3";
import thinkingSound from "./sounds/thinking.mp3"; 
import bgSound from "./sounds/bg_music.mp3";
```

These are basic assets like the default react libraries along with `useSound` which we will be using later in the code and lastly the `web3` library to interact with the blockchain.

After this let’s initialize the web3 library using the following line.

```
const web3 = new Web3(window.ethereum);
```

Now, let’s get started with the main `App()` function:

```
function App(){
//rest of the code will go here
}

return (
    //Return code goes here
);
}

export default App;
```

Let’s first create the App states, each of these states will manage the state of different functionality of the app. Just add the following code to `App()` function:

```
  const [account, setAccount] = useState("");
  const [hogwartsContract, setHogwartsContract] = useState(null);
  const [randomHouseContract, setRandomHouseContract] = useState(null);  
  const [house, setHouse] = useState("");
  const [house_slogan, sethouseSlogan] = useState("");
  const [minted, setMinted] = useState(false);
  const [connected, setConnected] = useState(false);
  const [loading, setLoading] = useState(false); 
  const [checkMintedSuccess, setCheckMintSuccess] = useState(0);
  const [counter, setCounter] = useState(30);
  const [displayCounter, setDisplayCounter] = useState(false);
  const [started, setStarted] = useState(false);
  const [userName, setUserName] = useState("");
  const [isUserNameSubmitted, setIsUserNameSubmitted] = useState(false);
  const [responseLoading, setResponseLoading] = useState(false);
```

Don’t worry!! You will learn about these states as we move forward with the code.

Next, let’s create two `const` which will store a default and dynamic loading message which will be used when the loading state is true:

```
const defaultLoadingMessage = "Ah, right then... hmm... right";
const dynamicLoadingMessage = `Ahh seems difficult, let me think harder, wait for ${counter}`;
```

Here, the counter is also a state which starts counting backwards from 60.

Now, lastly let’s implement the return statement:

```
return (
      <div className="App">
	       <img className="Hogwarts-logo" src={HogwartsLogo} alt="Hogwarts Logo" />
        <h1>Welcome to Hogwarts</h1>
			</div>
);
}
```

Here, we simply made a basic layout for our main page of the application. We made `div`, imported the image using `HogwartsLogo` that we imported at the start of the code and then added the `h1` heading.

## Basic structure

Here is how your basic structure will look like now:

```
import React, { useState, useEffect } from "react";
import useSound from 'use-sound';
import Web3 from "web3";
import HogwartsNFT from "./artifacts/HogwartsNFT.json"; 
import RandomHouseAssignment from "./artifacts/RandomHouseAssignment.json"; 
import HogwartsLogo from "./assets/hogwarts_logo.png"; 
import "./App.css";
import Lottie from "lottie-react";
import HPLoader from "./loaders/hpLoader.json"

//import audio
import gryffindorSound from "./sounds/gryffindor.mp3";
import hufflepuffSound from "./sounds/hufflepuff.mp3";
import ravenclawSound from "./sounds/ravenclaw.mp3";
import slytherinSound from "./sounds/slytherin.mp3";
import thinkingSound from "./sounds/thinking.mp3"; 
import bgSound from "./sounds/bg_music.mp3";

const web3 = new Web3(window.ethereum);

function App() {
  const [account, setAccount] = useState("");
  const [hogwartsContract, setHogwartsContract] = useState(null);
  const [randomHouseContract, setRandomHouseContract] = useState(null);  
  const [house, setHouse] = useState("");
  const [house_slogan, sethouseSlogan] = useState("");
  const [minted, setMinted] = useState(false);
  const [connected, setConnected] = useState(false);
  const [loading, setLoading] = useState(false); 
  const [checkMintedSuccess, setCheckMintSuccess] = useState(0);
  const [counter, setCounter] = useState(60);
  const [displayCounter, setDisplayCounter] = useState(false);
  const [started, setStarted] = useState(false);
  const [userName, setUserName] = useState("");
  const [isUserNameSubmitted, setIsUserNameSubmitted] = useState(false);
  const [responseLoading, setResponseLoading] = useState(false);

  const defaultLoadingMessage = "Ah, right then... hmm... right";
  const dynamicLoadingMessage = `Ahh seems difficult, let me think harder, wait for ${counter}`;

	return (
      <div className="App">
	       <img className="Hogwarts-logo" src={HogwartsLogo} alt="Hogwarts Logo" />
        <h1>Welcome to Hogwarts</h1>
			</div>
  );
}

export default App;
```

## Wrap up

In this lesson, we learned about the basic structure of the frontend and initialized the necessary libraries and assets. We also created the App states and implemented the return statement. This sets us up for further implementation of the functionality of the app.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/4.%20Add%20dApp%E2%80%99s%20Frontend/2.%20Let%E2%80%99s%20Implement%20the%20Basics.md

Let’s Implement the Basics

# Dive Deep Into the Code

Welcomeee! We have completed setting up the basic structure of our app, right? Now, let’s dig deep in!!

First, let’s code the component which will handle the MetaMask connection and also it will connect our dApp with the smart contract enabling us to interact with the contract.

## MetaMask Setup

Now, in the `App()` function, under the loading messages constants (`const`), we created in the last lesson paste these two `useEffects()`:

```
// To intialize metamask and connect with the smart contract
useEffect(() => {
    if (started) {
	    if (window.ethereum) {
	      setConnected(true);
	      window.ethereum.on("accountsChanged", (accounts) => {
	        // update the connection status when the user changes accounts
	        setAccount(accounts[0]);
	        setConnected(true);
	      });
	      window.ethereum.on("disconnect", () => {
	        // update the connection status when the user disconnects
	        setAccount("");
	        setConnected(false);
	        setMinted(false); // Reset the minted state when the user disconnects
	      });
	      window.ethereum.enable().then((accounts) => {
	        setAccount(accounts[0]);
	        const hogwartsAddress = "Your Hogwarts NFT smart contract address goes here";
	        const randomHouseAddress = "Your Random House Assignment smart contract address goes here";
	
	      const hogwartsInstance = new web3.eth.Contract(
	        HogwartsNFT.abi,
	        hogwartsAddress
	      );
	      const randomHouseInstance = new web3.eth.Contract(
	        RandomHouseAssignment.abi,
	        randomHouseAddress
	      );
	
	      setHogwartsContract(hogwartsInstance);
	      setRandomHouseContract(randomHouseInstance);
	    
	      
	      checkMinted(); // Check for a minted NFT when the app first loads
	      });
	    } else {
	      alert("Please install MetaMask to use this app!");
	    }
	  }
  }, [started]);

//To check for account and start changes
  useEffect(() => {
    if (started) {
    if (hogwartsContract|| randomHouseContract || account) {
      checkMinted();
    }
  }
  }, [account, started]);
```

Now, let us explain what we did here.

### First `useEffect`: Initial Setup

The first `useEffect` does several things:

1. **Check If MetaMask Exists**: The code starts by checking if `window.ethereum` exists, which is essentially a way to see if MetaMask is installed.
    
    ```
    if (window.ethereum) {
      setConnected(true);
    ```
    
    If MetaMask isn't installed, an alert prompts the user to install it.
    
    ```
    } else {
      alert("Please install MetaMask to use this app!");
    }
    ```
    
2. **Listening for Account Changes**: The hook listens for the event `"accountsChanged"` to detect any change in the connected MetaMask account.
    
    ```
    window.ethereum.on("accountsChanged", (accounts) => {
      setAccount(accounts[0]);
      setConnected(true);
    });
    ```
    
3. **Listening for Disconnects**: Similarly, the hook listens for the event `"disconnect"` to manage when a user disconnects their MetaMask account.
    
    ```
    window.ethereum.on("disconnect", () => {
      setAccount("");
      setConnected(false);
      setMinted(false);
    });
    ```
    
4. **Initialize Smart Contracts**: If MetaMask is enabled and the accounts are accessible, the code initializes two smart contracts, `HogwartsNFT` and `RandomHouseAssignment`.
    1. Make sure to add your respective contract address :
        - For `hogwartsAddress`, replace “Your Hogwarts NFT smart contract address goes here” with the contract address of `HogwartsNFT.sol`.
        - For `randomHouseAddress`, replace “Your Random House Assignment smart contract address goes here” with the contract address of `RandomHouseAssignment.sol`.
    
    ```
    window.ethereum.enable().then((accounts) => {
            setAccount(accounts[0]);
            const hogwartsAddress = "Your Hogwarts NFT smart contract address goes here";
            const randomHouseAddress = "Your Random House Assignment smart contract address goes here";
    
          const hogwartsInstance = new web3.eth.Contract(
            HogwartsNFT.abi,
            hogwartsAddress
          );
          const randomHouseInstance = new web3.eth.Contract(
            RandomHouseAssignment.abi,
            randomHouseAddress
          );
    ```
    
5. **Check Minted Status**: Finally, it invokes the `checkMinted()` function to see if an NFT has already been minted.
    
    ```
    checkMinted();
    ```
    

### Second `useEffect`: Staying Updated

The second `useEffect` is much simpler. Its sole purpose is to keep the app updated.

1. **Re-check Minted Status**: This block re-invokes `checkMinted()` whenever the `account` or `started` state changes, ensuring that the app's status is updated accordingly.
    
    ```
    useEffect(() => {
      if (started) {
        if (hogwartsContract || randomHouseContract || account) {
          checkMinted();
        }
      }
    }, [account, started]);
    ```
    

So summing it up, the first `useEffect` is all about setup and initial state, while the second `useEffect` ensures that the app remains current if something changes.

## Check if network is Polygon Mumbai or not

We will use the following code to check if the network our app is connected is Polygon Mumbai or not.

```
useEffect(() => {
    if(started && window.ethereum) {
      checkNetwork();
      
      window.ethereum.on("networkChanged", checkNetwork);
      
      return () => {
        window.ethereum.removeListener("networkChanged", checkNetwork);
      }
    }
  }, [started]);

const checkNetwork = async () => {

      const networkId = await window.ethereum.networkVersion;

    if(networkId == 80001) {
      setStarted(true);
      playBgSound(); 
      setResponseLoading(true);
    }
    else {
      alert("Please connect to Polygon Mumbai Testnet"); 
    }
  }
```

## Connect or disconnect wallet

Now, let’s code how we can implement the logic to connect or disconnect the wallet:

```
const disconnectMetamask = async () => {
    try {
      await window.ethereum.enable();
      setConnected(false);
      setAccount("");
      setHouse("");
      sethouseSlogan("");
      stopBgSound();
      setStarted(false);
      setIsUserNameSubmitted(false);
      setUserName("");
    } catch (err) {
      console.error(err);
    }
  };

  const connectMetamask = async () => {
    try {
      await window.ethereum.request({ method: "wallet_requestPermissions", params: [{ eth_accounts: {} }] });
      setConnected(true);
    } catch (err) {
      console.error(err);
    }
  };
```

In the `disconnectMetamask` function, the following line is trying to enable MetaMask.

```
await window.ethereum.enable();
```

Immediately after, we reset several state variables.

```
setConnected(false);
setAccount("");
//rest of the states
```

It also stops the background sound by calling the following function.

```
stopBgSound();
```

Any errors during this process are caught and logged.

```
catch (err) {
  console.error(err);
}
```

Switching to `connectMetamask`, the function begins by requesting permission from MetaMask.

```
await window.ethereum.request({ method: "wallet_requestPermissions", params: [{ eth_accounts: {} }] });
```

If the request is successful, it sets the connected status to `true`.

```
setConnected(true);
```

Just like the other function, errors are caught and logged.

```
catch (err) {
  console.error(err);
}
```

Summing up, `disconnectMetamask` is about disconnecting and resetting, while `connectMetamask` is for establishing a new connection. Both handle errors gracefully.

## Wrap up

In this lesson, we coded the component that handles the MetaMask connection. We also learned how to connect or disconnect the wallet and how to handle errors gracefully. Overall, we made significant progress in setting up the basic structure of our app.



https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/4.%20Add%20dApp%E2%80%99s%20Frontend/3.%20Dive%20Deep%20Into%20the%20Code.md

Dive Deep Into the Code

# Add More Functionalities

Welcomeee! We have added lots of code to our `App()` function. Time to add more code!

## Implement `requestNFT`

Let’s implement the logic to request NFT now. Add the following before the `return` statement in your `App()` function:

```
const requestNFT = () => {
    randomHouseContract.methods
        .requestNFT(userName)
        .send({ from: account, value: web3.utils.toWei("0", "ether") })
        .on("transactionHash", function (hash) {
            console.log("Transaction sent. Transaction hash:", hash);
            setLoading(true); // Set loading to true before sending the transaction

            // Play the thinking sound once the transaction is sent (user pays for the transaction)
            playThinkingSound();
        })
        .on("receipt", function (receipt) {
            console.log("Transaction successful:", receipt.transactionHash);
            checkNewMinted();
  
        })
        .on("error", (error) => {
            console.error("Error requesting NFT:", error);
            setLoading(false); // Set loading back to false if there's an error during the transaction
        });
};
```

Let us explain the code lines one-by-one before moving forward.

```
const requestNFT = () => {
```

- This line defines an arrow function named `requestNFT`. This function is intended to be called when a user wants to request an NFT from a smart contract.

```
randomHouseContract.methods.requestNFT(userName)
```

- This line uses the `randomHouseContract` object to call the `requestNFT` function of a smart contract. It appears to pass a `userName` parameter to this function.

```
.send({ from: account, value: web3.utils.toWei("0", "ether") })
```

- This line sends the transaction to the Ethereum network. It specifies the following details:
    - `from`: The Ethereum address (`account`) that is sending the transaction.
    - `value`: The amount of ether (0 ether in this case) to send along with the transaction. It may be used for gas costs or payments.

```
.on("transactionHash", function (hash) {
    console.log("Transaction sent. Transaction hash:", hash);
    setLoading(true);
    playThinkingSound();
})
```

- This part of the code listens for the `transactionHash` event, which is emitted when the transaction is initially sent. When the event occurs, it executes the provided function.
- Inside the function:
    - It logs the transaction hash to the console.
    - Sets the loading state to `true`. This is typically done to indicate that a transaction is being processed.
    - Plays a `thinking` sound, presumably to provide feedback to the user that their transaction is being processed.

```
.on("receipt", function (receipt) {
   console.log("Transaction successful:", receipt.transactionHash);
   checkNewMinted();
})
```

- This part of the code listens for the `receipt` event, which is emitted when the transaction is successfully mined and confirmed on the Ethereum network. When the event occurs, it executes the provided function.
- Inside the function:
    - It logs the transaction hash of the successful transaction to the console.
    - Calls the `checkNewMinted` function, presumably to check if the NFT minting was successful.

Just like the other functions, errors are caught and logged.

```
.on("error", (error) => {
    console.error("Error requesting NFT:", error);
    setLoading(false); 
});
```

- This part of the code listens for the "error" event, which is emitted if there is an error during the transaction (e.g., out of gas, insufficient funds). When the event occurs, it executes the provided error handling function.
- Inside the error handling function:
    - It logs the error to the console.
    - Sets the loading state back to `false`. This is done to indicate that the transaction failed or encountered an error.

## Implement `checkMinted`

Let’s write the code to check whether a user has minted an NFT and retrieve the user's name from a smart contract. Do remember to add all of these code inside of your `App()` function, before `return` statement.

1. `checkMinted` function:
    
    ```
    const checkMinted = async () => {
      await checkName();
      const minted = await hogwartsContract.methods.hasMintedNFT(account).call();
      console.log(minted);
    
      if (minted === true) {
        setMinted(true);
        await getHouseData();
        setLoading(false);
      } else {
        setMinted(false);
        setLoading(false);
      }
      setResponseLoading(false);
    };
    ```
    
    - This function is responsible for checking if the user has minted an NFT.
    - It starts by calling the `checkName` function to retrieve the user's name (assuming that's required).
    - It then calls the `hasMintedNFT` function of the `hogwartsContract` to check if the user has minted an NFT. The result is stored in the `minted` variable.
    - If `minted` is `true`, it sets the `minted` state to `true`, retrieves and displays the user's house data with the `getHouseData` function, and sets loading to `false`.
    - If `minted` is `false`, it sets the `minted` state to `false` and sets loading to `false`.
    - Finally, it sets `responseLoading` to `false`.
2. `checkName` function:
    
    ```
    const checkName = async () => {
      setLoading(true);
      const name = await hogwartsContract.methods.s_addressToName(account).call();
      if (name) {
        setUserName(name);
        setIsUserNameSubmitted(true);
      }
      console.log("name set");
    };
    ```
    
    - This function is responsible for checking and retrieving the user's name from the smart contract.
    - It sets loading to `true` to indicate that data retrieval is in progress.
    - It calls the `s_addressToName` function of the `hogwartsContract` to retrieve the user's name based on their Ethereum address (`account`).
    - If a name is returned (i.e., `name` is not falsw), it sets the user's name using `setUserName` and marks the user's name as submitted with `setIsUserNameSubmitted`.
    - It logs "name set" to the console.

## Implement `checkNewMinted`

Now, let’s write the code to periodically check if a user has minted an NFT:

```
  const checkNewMinted = async () => {
      setDisplayCounter(true); 
      setTimeout(async() => {
      const minted = await hogwartsContract.methods.hasMintedNFT(account).call();
      console.log(minted, checkMintedSuccess);
      if (minted === true){
        setMinted(true);
        getHouseData();
        checkName();
        setLoading(false);
        setCounter(3);
        setDisplayCounter(false);
      }
      else if(checkMintedSuccess < 3){
        setCheckMintSuccess(prev=>prev+1);
        setCounter(prev => prev - 1);
        checkNewMinted();}
      }, 800);
    };
```

- It sets the `displayCounter` state to `true`. This suggests that some kind of counter or progress indicator is displayed.
- It uses `setTimeout` to delay the execution of the code within the timeout function.
- Inside the timeout function:
    - It calls the `hasMintedNFT` function of the `hogwartsContract` to check if the user has minted an NFT. The result is stored in the `minted` variable.
    - It logs the value of `minted` and `checkMintedSuccess` to the console.
    - If `minted` is `true` (indicating the user has minted an NFT):
        - It sets the `minted` state to `true`.
        - It retrieves and displays the user's house data using the `getHouseData` function.
        - It checks and retrieves the user's name using the `checkName` function.
        - It sets the `loading` state to `false`.
        - It resets the counter to `3`.
        - It sets `displayCounter` to `false`.
    - If `minted` is not `true` and `checkMintedSuccess` is less than `3`:
        - It increments the `checkMintedSuccess` counter.
        - It decrements the `counter`.
        - It recursively calls the `checkNewMinted` function. This recursion continues for a maximum of 3 times (`checkMintedSuccess` being less than 3).

## Wrap up

This lesson covers adding more functionalities to an app, including implementing logic to request NFTs, checking if a user has minted an NFT, and periodically checking if a user has minted an NFT. 

In the next lesson, we will add final touches to our code.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/4.%20Add%20dApp%E2%80%99s%20Frontend/4.%20Add%20More%20Functionalities.md

Add More Functionalities

# Add the Final Touches

Greetings! So we have made significant improvement in our code, haven’t we? So let’s add more logic and complete our code in `App.js`.

## Implement `getHouseData`

Let’s code the logic to fetch the House data. Add it to the `App` function before `return` statement:

```
    const getHouseData = async () => {
    setLoading(true);
    const houseIndex = await hogwartsContract.methods.getHouseIndex(account).call();
    const addressToHouse = [
    "You belong in Gryffindor....", 
    "You belong in Hufflepuff....", 
    "You belong in wise old Ravenclaw....", 
    "You belong perhaps in Slytherin...."];
    setHouse(addressToHouse[houseIndex]);

    const sloganToHouse = [ 
      "Where dwell the brave at heart. Their daring, nerve, and chivalry, Set Gryffindors apart.",    
      "Where they are just and loyal. Those patient Hufflepuffs are true And unafraid of toil.",    
      "you’ve a ready mind. Where those of wit and learning, Will always find their kind.",    
      "You’ll make your real friends. Those cunning folks use any means, To achieve their ends."  ];      
    sethouseSlogan(sloganToHouse[houseIndex]);

    switch (houseIndex) {
      case '0':
        playGryffindorSound();
        break;
      case '1':
        playHufflepuffSound();
        break;
      case '2':
        playRavenclawSound();
        break;
      case '3':
        playSlytherinSound();
        break;
      default:
        break;
    }
    setLoading(false);
  };
```

### Explanation

Let us explain the code first.

```
//function to get the house of the contract
const getHouseData = async () => {
  setLoading(true);
```

- This block defines an asynchronous function named `getHouseData`.
- It is used to retrieve data related to a user's Hogwarts house.
- It sets the loading state to `true`, indicating that data retrieval is in progress.

```
  const houseIndex = await hogwartsContract.methods.getHouseIndex(account).call();
```

- This line uses the `hogwartsContract` to call the `getHouseIndex` function of the contract.
- It awaits the result (asynchronous operation) and stores the returned value in the `houseIndex` variable.
- This value represents the index of the user's Hogwarts house.

```
  const addressToHouse = [
    "You belong in Gryffindor....",
    "You belong in Hufflepuff....",
    "You belong in wise old Ravenclaw....",
    "You belong perhaps in Slytherin...."];
  setHouse(addressToHouse[houseIndex]);
```

- This block defines an array `addressToHouse` containing descriptions of the Hogwarts houses based on their index.
- It then sets the user's house description using the `setHouse` function based on the `houseIndex` obtained from the contract.

```
  const sloganToHouse = [
    "Where dwell the brave at heart. Their daring, nerve, and chivalry, Set Gryffindors apart.",
    "Where they are just and loyal. Those patient Hufflepuffs are true And unafraid of toil.",
    "you’ve a ready mind. Where those of wit and learning, Will always find their kind.",
    "You’ll make your real friends. Those cunning folks use any means, To achieve their ends."  ];
  sethouseSlogan(sloganToHouse[houseIndex]);
```

- Time to define the characteristics of each House.
- So similar to the previous block, this one defines an array `sloganToHouse` containing house slogans based on their index.
- It then sets the user's house slogan using the `sethouseSlogan` function based on the `houseIndex` obtained from the contract.

```
  switch (houseIndex) {
    case '0':
      playGryffindorSound();
      break;
    case '1':
      playHufflepuffSound();
      break;
    case '2':
      playRavenclawSound();
      break;
    case '3':
      playSlytherinSound();
      break;
    default:
      break;
  }
```

- This block uses a `switch` statement to play a specific sound or perform an action based on the `houseIndex`.
- It checks the value of `houseIndex` and calls a corresponding sound-playing function based on the user's house.

```
  setLoading(false);
};
```

- Finally, this line sets the loading state to `false`, indicating that data retrieval and processing are complete.

## Implement return functions

Let’s define several React functional components used for rendering different views and interactions in a web application. 

### `showNameField` Component:

```
const showNameField = () => (
  <div className="form">
    <input
      className="input-box"
      type="text"
      placeholder="Enter your name"
      value={userName}
      onChange={(e) => setUserName(e.target.value)}
    />
    <button
      className="form-button"
      onClick={() => {
        setUserName(userName);
        setIsUserNameSubmitted(true);
      }}
    >
      Submit
    </button>
  </div>
);
```

- This component renders a form for users to enter their names.
- It includes an input field and a submit button.
- When the submit button is clicked, it sets the user's name and marks it as submitted.

### `startButton` Component:

```
const startButton = () => (
  <button className="start-button" onClick={() => {checkNetwork()}}>
    Let's go to the Great Hall
  </button>
);
```

- This component renders a "Start" button.
- When clicked, it triggers several actions, such as setting the application as started, playing background sound, and setting response loading to true.

### `mintedView` Component:

```
const mintedView = () => (
  <>
    {loading || !house ? (
      <p>
        {displayCounter
          ? counter
            ? dynamicLoadingMessage
            : defaultLoadingMessage
          : defaultLoadingMessage}
      </p>
    ) : (
      <>
        <p>{house}</p>
        {house_slogan.split('. ').map((slogan, index) => (
          <p key={index}>{slogan}</p>
        ))}
      </>
    )}
  </>
);
```

- This component renders different views based on loading state and house data.
- If data is loading or the `house` is not available, it displays loading messages.
- Otherwise, it displays the user's house and its slogan.

### `mintNFT` Component:

```
const mintNFT = () => (
  <>
    {!userName || !isUserNameSubmitted ? (
      showNameField()
    ) : !loading ? (
      <button onClick={requestNFT} disabled={minted}>
        Let's choose your house
      </button>
    ) : (
      <p className="loading-button-msg">
        {displayCounter
          ? counter
            ? dynamicLoadingMessage
            : defaultLoadingMessage
          : defaultLoadingMessage}
      </p>
    )}
  </>
);
```

- This component renders either the name input field (if the user's name is not submitted) or a button to choose a Hogwarts house (if data is not loading).
- If data is loading, it displays a loading message.

### `connectedView` Component:

```
const connectedView = () => (
  <>
    {responseLoading ? (
      <Lottie animationData={HPLoader} style={style} loop={true} />
    ) : minted ? (
      mintedView()
    ) : (
      mintNFT()
    )}
    <button className="metamask-button" onClick={disconnectMetamask}>
      disconnect wallet
    </button>
  </>
);
```

- This component renders different views based on the `responseLoading` state and whether the user has minted an NFT. If data is still loading, it displays an animation.
- If the user has minted an NFT, it shows the minted view; otherwise, it displays the minting interface. Additionally, it provides a button to disconnect the wallet.

### `gameStarted` Component:

```
const gameStarted = () => (
  <>
    {connected ? (
      connectedView()
    ) : (
      <button className="metamask-button" onClick={connectMetamask}>
        connect wallet
      </button>
    )}
  </>
);
```

- This component checks if the user is connected to a wallet.
- If connected, it shows the connected view; otherwise, it provides a button to connect the wallet.

Finally, add the following line to the `div` that we added in the `return` statement of `App` function.

```
{started ? gameStarted() : startButton()}
```

- This line will check if the `started` useState is `true` or `false`.
- If true, it will call `gameStarted()` function and if false, it will call `startButton()` function.

## Complete code

The complete code for `App.js` is:

```
import React, { useState, useEffect } from "react";
import useSound from 'use-sound';
import Web3 from "web3";
import HogwartsNFT from "./artifacts/HogwartsNFT.json"; 
import RandomHouseAssignment from "./artifacts/RandomHouseAssignment.json"; 
import HogwartsLogo from "./assets/hogwarts_logo.png"; // import the image
import "./App.css";
import Lottie from "lottie-react";
import HPLoader from "./loaders/hpLoader.json"

//import audio
import gryffindorSound from "./sounds/gryffindor.mp3";
import hufflepuffSound from "./sounds/hufflepuff.mp3";
import ravenclawSound from "./sounds/ravenclaw.mp3";
import slytherinSound from "./sounds/slytherin.mp3";
import thinkingSound from "./sounds/thinking.mp3"; 
import bgSound from "./sounds/bg_music.mp3";

const web3 = new Web3(window.ethereum);

function App() {
  const [account, setAccount] = useState("");
  const [hogwartsContract, setHogwartsContract] = useState(null);
  const [randomHouseContract, setRandomHouseContract] = useState(null);  
  const [house, setHouse] = useState("");
  const [house_slogan, sethouseSlogan] = useState("");
  const [minted, setMinted] = useState(false);
  const [connected, setConnected] = useState(false);
  const [loading, setLoading] = useState(false); 
  const [checkMintedSuccess, setCheckMintSuccess] = useState(0);
  const [counter, setCounter] = useState(60);
  const [displayCounter, setDisplayCounter] = useState(false);
  const [started, setStarted] = useState(false);
  const [userName, setUserName] = useState("");
  const [isUserNameSubmitted, setIsUserNameSubmitted] = useState(false);
  const [responseLoading, setResponseLoading] = useState(false);

  //initialize audio
  const [playBgSound, { stop: stopBgSound }] = useSound(bgSound, { loop: true });
  const [playThinkingSound] = useSound(thinkingSound, { loop: false });
  const [playGryffindorSound] = useSound(gryffindorSound, { loop: false });
  const [playHufflepuffSound] = useSound(hufflepuffSound, { loop: false });
  const [playRavenclawSound] = useSound(ravenclawSound, { loop: false });
  const [playSlytherinSound] = useSound(slytherinSound, { loop: false });


  const defaultLoadingMessage = "Ah, right then... hmm... right";
  const dynamicLoadingMessage = `Ahh seems difficult, let me think harder, wait for ${counter}`;
  
  useEffect(() => {
    if(started && window.ethereum) {
      checkNetwork();
      
      window.ethereum.on("networkChanged", checkNetwork);
      
      return () => {
        window.ethereum.removeListener("networkChanged", checkNetwork);
      }
    }
  }, [started]);

  useEffect(() => {
    if (started) {
    if (window.ethereum) {
      setConnected(true);
      window.ethereum.on("accountsChanged", (accounts) => {
        // update the connection status when the user changes accounts
        setAccount(accounts[0]);
        setConnected(true);
      });
      window.ethereum.on("disconnect", () => {
        // update the connection status when the user disconnects
        setAccount("");
        setConnected(false);
        setMinted(false); // Reset the minted state when the user disconnects
      });
      window.ethereum.enable().then((accounts) => {
        setAccount(accounts[0]);
        const hogwartsAddress = "0x668E74207022aE0bEcEC3f303113E4586f5D673d";
        const randomHouseAddress = "0x78AeF6495Ca7443dEab2F3aBfAF414D221038C65";

      const hogwartsInstance = new web3.eth.Contract(
        HogwartsNFT.abi,
        hogwartsAddress
      );
      const randomHouseInstance = new web3.eth.Contract(
        RandomHouseAssignment.abi,
        randomHouseAddress
      );

      setHogwartsContract(hogwartsInstance);
      setRandomHouseContract(randomHouseInstance);
    
      
      checkMinted(); // Check for a minted NFT when the app first loads
      });
    } else {
      alert("Please install MetaMask to use this app!");
    }
  }
  }, [started]);

  useEffect(() => {
    if (started) {
    if (hogwartsContract|| randomHouseContract || account) {
      checkMinted();
    }
  }
  }, [account, started]);

  const disconnectMetamask = async () => {
    try {
      await window.ethereum.enable();
      setConnected(false);
      setAccount("");
      setHouse("");
      sethouseSlogan("");
      stopBgSound();
      setStarted(false);
      setIsUserNameSubmitted(false);
      setUserName("");
    } catch (err) {
      console.error(err);
    }
  };

  const checkNetwork = async () => {

      const networkId = await window.ethereum.networkVersion;

    if(networkId == 80001) {
      setStarted(true);
      playBgSound(); 
      setResponseLoading(true);
    }
    else {
      alert("Please connect to Polygon Mumbai Testnet"); 
    }
  }
  

  console.log(house);
  const connectMetamask = async () => {
    try {
      await window.ethereum.request({ method: "wallet_requestPermissions", params: [{ eth_accounts: {} }] });
      setConnected(true);
    } catch (err) {
      console.error(err);
    }
  };

  const requestNFT = () => {
    randomHouseContract.methods
        .requestNFT(userName)
        .send({ from: account, value: web3.utils.toWei("0", "ether") })
        .on("transactionHash", function (hash) {
            console.log("Transaction sent. Transaction hash:", hash);
            setLoading(true); // Set loading to true before sending the transaction

            // Play the thinking sound once the transaction is sent (user pays for the transaction)
            playThinkingSound();
        })
        .on("receipt", function (receipt) {
            console.log("Transaction successful:", receipt.transactionHash);
            checkNewMinted();
  
        })
        .on("error", (error) => {
            console.error("Error requesting NFT:", error);
            setLoading(false); // Set loading back to false if there's an error during the transaction
        });
};
  
  //function to get the house of the contract
  const getHouseData = async () => {
    setLoading(true);
    const houseIndex = await hogwartsContract.methods.getHouseIndex(account).call();
    const addressToHouse = [
    "You belong in Gryffindor....", 
    "You belong in Hufflepuff....", 
    "You belong in wise old Ravenclaw....", 
    "You belong perhaps in Slytherin...."];
    setHouse(addressToHouse[houseIndex]);

    const sloganToHouse = [ 
      "Where dwell the brave at heart. Their daring, nerve, and chivalry, Set Gryffindors apart.",    
      "Where they are just and loyal. Those patient Hufflepuffs are true And unafraid of toil.",    
      "you’ve a ready mind. Where those of wit and learning, Will always find their kind.",    
      "You’ll make your real friends. Those cunning folks use any means, To achieve their ends."  ];      
    sethouseSlogan(sloganToHouse[houseIndex]);

    switch (houseIndex) {
      case '0':
        playGryffindorSound();
        break;
      case '1':
        playHufflepuffSound();
        break;
      case '2':
        playRavenclawSound();
        break;
      case '3':
        playSlytherinSound();
        break;
      default:
        break;
    }
    setLoading(false);
  };

  // function to check if the user has minted an NFT
  const checkMinted = async () => {
    await checkName();
    const minted = await hogwartsContract.methods.hasMintedNFT(account).call();
    console.log(minted);
    if (minted === true){
      setMinted(true);
      await getHouseData();
      setLoading(false);
    }
    else {
    setMinted(false);
    setLoading(false);
    }
    setResponseLoading(false);
 
  };

  console.log(userName);
  const checkName = async () => {
    setLoading(true);
    const name = await hogwartsContract.methods.s_addressToName(account).call();
    if (name) {
    setUserName(name);
    setIsUserNameSubmitted(true);}
    console.log("name set");    
  };

  // function to check if the user has minted an NFT
  const checkNewMinted = async () => {
      setDisplayCounter(true);  // Set this to true here
      setTimeout(async() => {
      const minted = await hogwartsContract.methods.hasMintedNFT(account).call();
      console.log(minted, checkMintedSuccess);
      if (minted === true){
        setMinted(true);
        getHouseData();
        checkName();
        setLoading(false);
        setCounter(3); // Reset the counter
        setDisplayCounter(false);  // Reset to false once confirmed
      }
      else if(checkMintedSuccess < 3){
        setCheckMintSuccess(prev=>prev+1);
        setCounter(prev => prev - 1);  // Decrement the counter
        checkNewMinted();}
      }, 800);
    };
    
    const showNameField = ()=>(
      <div className="form">
        <input className="input-box"
          type="text" 
          placeholder="Enter your name" 
          value={userName} 
          onChange={(e) => setUserName(e.target.value)}
          />
        <button className="form-button" onClick={() => {setUserName(userName); setIsUserNameSubmitted(true);}}>Submit</button>
      </div>)

    const startButton = ()=>(
      <button className="start-button" onClick={() => {checkNetwork()}}>
      Let's go to the Great Hall
      </button>)

    const mintedView = ()=> (
        <>
          {loading || !house ? (
            <p>{displayCounter ? (counter ? dynamicLoadingMessage : defaultLoadingMessage) : defaultLoadingMessage}</p>
          ) : (
            <>
              <p>{house}</p>
              {house_slogan.split('. ').map((slogan, index) => (
                <p key={index}>{slogan}</p>
              ))}
            </>
          )}
        </>
      
    )

    const mintNFT = () => (
      
        <>
          {!userName || !isUserNameSubmitted ? showNameField() :
          !loading ? <button onClick={requestNFT} disabled={minted}>Let's choose your house</button> : <p className="loading-button-msg">{displayCounter ? (counter ? dynamicLoadingMessage : defaultLoadingMessage) : defaultLoadingMessage}</p>
          }
        </>
      
    )

    const style = {
      height: 250,
    };

    const connectedView = ()=> (
      <>
         {responseLoading ? <Lottie animationData={HPLoader} style={style} loop={true} /> : minted ? mintedView() : mintNFT()}
      <button className="metamask-button" onClick={disconnectMetamask}> disconnect wallet </button>
      </>
    )

    const gameStarted = ()=>(
      <>
      {  
        connected ? connectedView () : <button className="metamask-button" onClick={connectMetamask}> connect wallet </button>
      }    
      </>
    )

    return (
      <div className="App">
        <img className="Hogwarts-logo" src={HogwartsLogo} alt="Hogwarts Logo" />
        <h1>Welcome to Hogwarts {userName}</h1>
        
        {started ? gameStarted() : startButton()}
      </div>
    );
}  
    
export default App;
```

**Note:** Don’t forget to paste your `HogwartsNFT` and `RandomHouseAssignment` contract address.

## Wrap up

This lesson presented a complete React app that interacts with a Solidity smart contract on the Ethereum blockchain. The app mints a non-fungible token (NFT) for the user and assigns them to a Hogwarts house. It also uses Web3 to interact with the Ethereum blockchain and MetaMask to connect to users' wallets. The lesson covered various React components and their functionalities, including checking if the user has already minted an NFT, minting a new NFT, and displaying the user's assigned Hogwarts house. Overall, the lesson provided a comprehensive example of how to use React and Web3 to create a decentralized application that interacts with the blockchain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/4.%20Add%20dApp%E2%80%99s%20Frontend/5.%20Add%20the%20Final%20Touches.md

Add the Final Touches

# Run the dApp

We are done with the code. Now finallyy we can run it. Let’s go!!

Open the terminal and run the following command:

```
npm start
```

And you can experience interacting with your dApp:

![hogwatrs_final.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/What%20Are%20We%20Building%20Today/Frame_3560365_(28).webp?raw=true)

## Wrap up

In this lesson, we have completed the code for the dApp and learned how to run it. By running the command `npm start` in the terminal, we can now interact with our dApp. This concludes our lesson.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/4.%20Add%20dApp%E2%80%99s%20Frontend/6.%20Run%20the%20dApp.md

Run the dApp

# Let’s Wrap It Up

Alright, let's wrap it up and celebrate your incredible journey! 🎉 It's time to take a moment and reflect on everything you've learned in this course. Get ready for a quick recap that will leave you feeling accomplished and ready to conquer the world! 

## Setting up the Development Environment

You set up the development environment and installed all the necessary dependencies. You learned how to:

- set up the testnet environment
- connect your Metamask wallet
- fetch fake MATIC
- set Hardhat project
- secure private data
- create an API key for PolygonScan
- set up Chainlink

## Writing smart contracts

You wrote `HogwartsNFT.sol` that allows the owner to mint non-fungible tokens representing the four Hogwarts houses. And you also wrote `RandomHouseAssignment.sol` to randomly assign Hogwarts houses to users. You used Chainlink's VRF service to generate random numbers, and then minted an NFT for the user with the randomly assigned house.

## Compiling the contracts

You wrote the deploy scripts and update the necessary files to compile the contracts.

## Adding frontend

You added frontend to your dApp, learned to integrate the frontend with the backend (smart contracts) and interacted with it.

## ⚒️ 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://bit.ly/hogwarts-dapp-twitter) and [LinkedIn](https://bit.ly/hogwarts-dapp-linkedin) as well. 🫶



## 🎊 Congratulations

You have completed the tutorial and are now equipped with the knowledge to create a dApp.

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20Hogwarts%20Sorting%20Cap%20dApp%20on%20the%20Polygon%20Mumbai/5.%20Wrap%20Up/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Warden Protocol

30 days of solidity

Fuel Marathon

Aptos Marathon

Core Marathon

Sui Marathon

30 Days of Solidity

AI Tools

30 Days of Solidity