Merge pull request #238 from Developer-DAO/lesson3-code-update

Lesson3 code update

Author: elPiablo

pages/lessons/projects/3.mdx

@@ -58,7 +58,8 @@ Now that we have set the stage, it's time to dive into the exciting world of tie
 - Creating tiered NFTs with varying levels of rarity and attributes
 - Write scripts for deployment
 - Exploring additional functionalities and possibilities with tiered NFTs ... in the smart contract!
-- Showcasing and trading your tiered NFTs on a public marketplace
+- Securely manage sensitive environment variables
+- Showcasing your tiered NFTs on a public marketplace
 
 ### Developer tooling
 
@@ -136,7 +137,7 @@ last prompt. If they didn’t install or we accidentally chose ‘n’, we can a
 install them manually with:
 
 ```bash
-npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox @nomicfoundation/hardhat-chai-matchers
+npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
 ```
 </Callout>
 In a Hardhat project, some of the default folders are:
@@ -197,6 +198,9 @@ contract defined, we can add the logic and the variables we need to store. As we
 
 Let’s get started by inheriting OpenZeppelin's ERC721.sol like we did last time. We add a constructor to our contract, which will mirror the one from ERC721.sol. 
 
+ {/* @wolovim optional line?: Unlike in our *Basic NFT* lesson, where we added a third parameter to the constructor for storing the token's baseURI, we will have a different approach this time, which we will come to later. */}
+
+
 ```solidity
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.12;
@@ -218,7 +222,7 @@ Now let’s go ahead and add a mint function which will call `_safeMint` from th
 // SPDX-License-Identifier: MIT
 pragma solidity 0.8.12;
 
-import '@openzeppelin/contracts/token/ERC721/ERC721.sol'
+import '@openzeppelin/contracts/token/ERC721/ERC721.sol';
 
 contract TierNFT is ERC721 {
 
@@ -846,11 +850,11 @@ async function main() {
     COLLECTION_NAME,
     COLLECTION_SYMBOL,
   )
-  await contract.deployed()
+
+  await contract.waitForDeployment()
   // Print our newly deployed contract address
-  console.log(`Contract deployed to ${contract.address}`)
+  console.log("Contract deployed at ", await contract.getAddress())
 }
-
 /** Run Main function - Do not change **/
 main().catch((error) => {
   console.error(error)
@@ -862,13 +866,13 @@ main().catch((error) => {
   will tell Hardhat exactly **what** to deploy.
 - With `const COLLECTION_NAME = "TierNFT"` and
   `const COLLECTION_SYMBOL = "Tier"` - we define the *name* and *symbol* to pass to the constructor for the deployment.
-- `hre.ethers.getContractFactory(CONTRACT_NAME)` - this asks Hardhat Runtime
-  Environment to get us a contract factory for our contract specified by `CONTRACT_NAME`. A contract factory is a template that allows us to deploy instances of that contract, which allows many advantages.
+- `hre.ethers.getContractFactory(CONTRACT_NAME)` - this asks `hre` (Hardhat Runtime
+  Environment) to get us a contract factory for our contract specified by `CONTRACT_NAME`. A contract factory is a template that allows us to deploy instances of that contract, which allows many advantages.
 - `contractFactory.deploy` - we are asking the contract factory to deploy an instance of our
   contract. This is the deploy transaction!
 - `COLLECTION_NAME, COLLECTION_SYMBOL` - these are the parameters for our
   contract's constructor function to set up its initial state.
-- `await contract.deployed()` - waits for the transaction to be approved by the network validators, and confirms that the deployment of the contract was successful, telling us that it's ready for use on the blockchain.
+- `await contract.waitForDeployment()` - waits for the transaction to be approved by the network validators, and confirms that the deployment of the contract was successful, telling us that it's ready for use on the blockchain.
 - Running the `main().catch( … )` script at the very end makes sure that all the previous
   code is executed, and also logs any errors, and prints them to the console.
 
@@ -911,6 +915,8 @@ Note: **Always make sure to use a separate browser profile, with a separate wall
 
 ### Getting Some Testnet Funds
 
+{/* @wolovim, maybe we should give a couple of testnet options, just in case. what do you think?*/}
+
 A testnet is a sandbox environment where developers
 can test, create and modify functionalities, monitor and simulate a mainnet blockchain's network
 performance, fix bugs and other network failures without having to worry about breaking a main chain, and paying in real crypto coins to do so! Mainnets cost - testnets generally don't. 
@@ -925,8 +931,7 @@ Note: Testnet and mainnet are separate networks. You can't for example send toke
 ### Personal Security
 Take your time to understand the *good practices* in this section. Before we deploy, we need to add a `.env` file to our root folder to make sure we are **not pushing and therefore exposing our private keys in public repositories**. 
 
-For your wallet's private key, the most sensitive data of the project, you need to open Metamask. Click on the three dots next to your *Account Name*, and then on *Account Details*, click on *Export Private Key*. It will ask for your Metamask password, the one you use to log in to your wallet each session, not your seed phrase. It also shows you a
-notice so you know that you are entering the *danger zone*. Confirm and you'll be able to copy your private key. Add your private key into the `.env` file like so:
+For your wallet's private key, the most sensitive data of the project, you need to open Metamask. Click on the three dots next to your *Account Name*, and then on *Account Details*, click on *Show Private Key*. It will ask for your Metamask password, the one you use to log in to your wallet each session, not your seed phrase. It also shows you a warning to 'Never disclose this key'. Confirm and you'll be able to copy your private key. Add your private key into the `.env` file like so:
 
 ```bash
 PRIVATE_KEY=f8abc629b...
@@ -988,47 +993,49 @@ async function main() {
   const contractFactory = await hre.ethers.getContractFactory(CONTRACT_NAME)
   const contract = await contractFactory.attach(CONTRACT_ADDRESS)
   // Print our newly deployed contract address
-  console.log(`Attached contract: ${contract.address}`)
+  console.log("Attached contract ", await contract.getAddress())
 
   // Call the mint function for Tier 0
   let txn = await contract.mint({
-    value: hre.ethers.utils.parseEther(VALUE_TIER_0),
+    value: hre.ethers.parseEther(VALUE_TIER_0),
   })
   await txn.wait() // Wait for the NFT to be minted
   console.log('Minted a Tier 0 NFT!')
 
   // Call the mint function for Tier 1
   txn = await contract.mint({
-    value: hre.ethers.utils.parseEther(VALUE_TIER_1),
+    value: hre.ethers.parseEther(VALUE_TIER_1),
   })
   await txn.wait() // Wait for the NFT to be minted
   console.log('Minted a Tier 1 NFT!')
 
   // Call the mint function for Tier 2
   txn = await contract.mint({
-    value: hre.ethers.utils.parseEther(VALUE_TIER_2),
-  })
+    value: hre.ethers.parseEther(VALUE_TIER_2),
+    })  
   await txn.wait() // Wait for the NFT to be minted
   console.log('Minted a Tier 2 NFT!')
 
-  let totalSupply = await contract.totalSupply()
-  console.log("Collection's new totalSupply: ", totalSupply)
+  // Print total number of minted NFTs
+let totalSupply = await contract.totalSupply()
+console.log("Collection's new totalSupply: ", totalSupply)
 }
 
 /** Run Main function - Do not change **/
 main().catch((error) => {
   console.error(error)
   process.exitCode = 1
 })
+
 ```
 
 - `const contract = await contractFactory.attach(CONTRACT_ADDRESS)` will
   make sure that we are not deploying the contract again. Instead we need
   Hardhat to use the contract addresss we just deployed to the testnet.
 - `let txn = await contract.mint(...` is calling the mint function.
-- `value: hre.ethers.utils.parseEther(VALUE_TIER_0)` - defines the value that we
+- `value: hre.ethers.parseEther(VALUE_TIER_0)` - defines the value that we
   want to send to the mint function. This defines which *Tier* we get.
-- `ethers.utils.parseEther` - here we use *Ethers* to translate the value into wei i.e. multiply it with 10\*\*18  
+- `ethers.parseEther` - here we use *Ethers* to translate the value into wei i.e. multiply it with 10\*\*18  
 - `let totalSupply = await contract.totalSupply()` - is calling the
   `totalSupply()` function to check if the 3 NFTs minted correctly.
 <br/>

utils/questions/lesson-3/4-deploy-scripts/Q2.json

@@ -1,5 +1,5 @@
 {
-  "question": "What does the `await contract.deployed()` line do in the code?",
+  "question": "What does the `await contract.waitForDeployment()` line do in the code?",
   "options": [
     {
       "answer": " It deploys the contract to the blockchain."