An in-depth learning track designed for developers to excel in Core, mastering the skills needed to create high-quality, secure dApps on a Bitcoin-aligned chain, and push the boundaries of blockchain innovation with a focus on security.






Master Core Development, Secure the Future


Dive into the exciting world of Core blockchain with our hands-on course in building a Social Media DApp! You'll sharpen your Solidity skills while creating a dynamic, interactive platform from scratch. This course guides you through every step—from setting up your development environment to deploying your dApp on the Core blockchain. Along the way, you'll master constants, variables, structs, and functions, crafting a unique social media experience. Whether you're a seasoned developer or just getting started, this course will supercharge your knowledge of Solidity and Core development!

# What Are We Building Today

Hey everyone!! We are so excited to see you in another course in our Core series. We promise this is gonna be super fun and you will get so much to learn! You might wonder that what are we building in this course. Well, we are building a very interesting project which is a pseudonymous social media forum. 

Pro tip: Staying connected with blockchain projects through their official GitHub repos can lead to unexpected perks. Many chains reward active community members with airdrops and other incentives. Make sure to follow [Core's repo](github.com/coredao-org) to stay in the loop!

![Intro.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/1.%20What%20Are%20We%20Building%20Today/Intro.png?raw=true)

In this dApp, we will create a smart contract to create your post and have additional functionalities like liking, unliking posts and even commenting on posts. We are already filled with enthusiasm to take you through this one and hope you are too! 

So get ready to get on board with us on this epic adventure! 

### Why a Decentralized Social Media Platform?

This is going to equip you with a great deal of knowledge of decentralized social media dApp. Today, we have centralized social media platforms all over, So wouldn’t it be fun to build our own decentralized one?

- Learn and build features used in our everyday social media app
- Earn a badass NFT badge that shows your skills.

## Course Overview

We will:

1. Setting up Core blockchain development environment
2. Learn how to develop smart contracts
3. Learn how to build and deploy a Social Media dApp using Solidity

## Who exactly should take this course?

This course is for beginner to intermediate Web3 developers who wish to learn about Core blockchain and have completed our previous courses on the Core blockchain. You should have basic programming knowledge as it will help you have a quick start to this course but if not, we are here for you!

## What will you be getting out of this course?

You will be getting the following outcomes when you complete this course:

1. Build a decentralized Pseudonymous social forum.
2. Create a user authentication and profile management system.
3. Develop a post creation feature with likes and comments functionality.
4. Claim your NFT on course completion.

## Tool Time: Gathering Your Gear

There are a few tools that you need to install to proceed with the course. Make sure you have the following:

1.  Download & Install:
    1. [MetaMask.io](https://metamask.io/)
    2. [Node.js](https://nodejs.org/)
    3. [Visual Studio](https://code.visualstudio.com/)
        1. **Power-Up:** Install the "Solidity" extension. You can use the following extension.
            
            ![solidity-extension.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/3%20Setting%20Up%20the%20Project%20Structure/solidity-extension.png?raw=true)
            
2. Connect Metamask to your Core Testnet with the RPC URL of [https://rpc.test.btcs.network](https://rpc.test.btcs.network/).
3. Fetch some tokens from the [Core testnet faucet](https://scan.test.btcs.network/faucet) by entering your wallet address to receive 1 CORE.

## Proof of completion

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

![core c5.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/1.%20What%20Are%20We%20Building%20Today/core_c5.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/Jf4ArqVb) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [Github](github.com/0xmetaschool), it would be a great support. 🫣
4. Stay happy and positive!

Alright guys, no need to wait any longer. Let’s get started!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C5%20Build%20Decentralized%20Social%20Media%20DApp%20on%20Core/1.%20Getting%20Started/1.%20What%20Are%20We%20Building%20Today.md

What Are We Building Today

# Quick overview of the DApp

Hello and welcome everyone! In this lesson, we'll explore the core features and functionality of our project, including user management, posting, liking, commenting, and grouping. We'll also break down the key steps to bring our dApp to life, outlined in our handy checklist. So let’s get started.

## What are we building?

The dApp we are building is a basic decentralized social network where users can register, create text posts, like and comment on others' posts. Let’s get into a bit more detail about each function. 

1. **User Management**
    - **User Registration**: Users can register themselves by providing a username and bio. Each user is identified by their wallet address.
    - **Conditions**:
        - A user can register only once.
        - The username must be unique for each address.
2. **Posts**
    - **Creating Posts**: Registered users can create posts with textual content. Each post is associated with a unique post ID and tracks the number of likes.
        - **Conditions**:
            - Only registered users can create posts.
    - **Liking/Unliking Posts**: Users can like or unlike posts. The contract keeps track of who liked each post to prevent multiple likes from the same user
        - **Conditions**:
            - Only registered users can like or unlike posts.
            - Users can only like a post once and can unlike it if they have liked it before.
3. **Comments**
    - **Commenting on Posts**: Users can add comments to any post. Each comment has a unique comment ID tied to a specific post.
    - **Conditions**:
        - Only registered users can comment on posts.
        - The post must exist for a comment to be added.

Here’s how you will be interact with the dApp:

![01.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/2.%20Quick%20overview%20of%20the%20DApp/01.gif?raw=true)

## The Checklist

Alright, let's get organized! Here's a rundown of what we need to do to bring our decentralized social network to life:

- **Set up the project structure**: We'll get everything in order and set up our project so that our code is tidy and easy to navigate.
- **Design the smart contract architecture**: We'll plan out how our smart contract will be structured for our dApp.
- **Create user authentication and profile management**: We'll make sure users can register and log in to their profiles securely.
- **Build the post creation feature**: Users will be able to share their thoughts and ideas with the community by creating posts.
- **Add likes and comments to posts**: We'll make it easy for users to engage with each other's content by liking and commenting on them.
- **Bringing it all together**: We will build and deploy our final smart contract and integrate it with our frontend boilerplate to fully build up our dApp.

That's it! Let's get started and make this dApp a reality.

## Wrap Up

That's a wrap! You now know what we're building and what's coming up next. Take a glance at the checklist, get excited, and let's dive in! We'll see you in the next lesson, where we'll start building our decentralized social network.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C5%20Build%20Decentralized%20Social%20Media%20DApp%20on%20Core/1.%20Getting%20Started/2.%20Quick%20overview%20of%20the%20DApp.md

Quick overview of the DApp

# Writing Smart Contract Basics

In this lesson, we will explore the architecture of a Solidity smart contract designed for a social media platform like what structs or mapping we need. But this time, we won’t make it easy for you. We do have a few assignments for you to solve to test your knowledge. So let’s dive into it right away~

## Setting Up Your Project

We will first make sure that we are at the right branch. Run the following command to be at the `boilerplate01` branch. At `boilerplate01`, we have made a basic HardHat project for you with the empty files. You’ll have to implement the code in those files.

```
git checkout boilerplate01
cd build-social-media-dapp-on-core
```

Navigate to `contracts/Metacircle.sol` and we have implemented basics there with a few missing pieces of code left for you to fill out. Let’s go through them one by one.

![core c5 (10).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(10).jpg?raw=true)

## Contract Declaration and Structs

First, we have contract and structs declarations. We defined three stucts: `User`, `Post`, and `Comment`. Do we need any other struct?

![core c5 (7).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(7).jpg?raw=true)

## User Struct

We have our first struct named `User` and it has the following variables in it:

- **userAddress:** The user's Core chain address.
- **username:** The display name chosen by the user.
- **bio:** A short biography or description of the user.

And our first assignment! Replace `YOUR_CODE_GOES_HERE` in Line `9` with the ***data type*** of `userAddress`. And the hint is that the data type is part of the variable name 😛

![core c5 (9).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(9).jpg?raw=true)

## Post Struct

We have our next struct named `Post` and it has the following variables in it:

- **postId:** A unique identifier for each post.
- **author:** The address of the user who created the post.
- **content:** The content of the post.
- **likes:** The count of likes the post has received.
- **likedBy:** A mapping to track which users have liked the post.

Time for assignment #2! Replace `YOUR_CODE_GOES_HERE` in Line `20` with the ***data type*** of `likes`. 

**Hint:** It’s a count so what data type is the best to store it?

![core c5 (3).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(3).jpg?raw=true)

## Comment Struct

The last struct is named `Comment` and it has the following variables in it:

- **commentId:** A unique identifier for each comment.
- **authorUsername:** The address of the user who wrote the comment.
- **postId:** The ID of the post the comment is associated with.
- **content:** The content of the comment.

Time for assignment #3! Replace `YOUR_CODE_GOES_HERE` in Line `31` with the ***data type*** of `content`. 

**Hint:** This variable will contain the sentences or paragraphs entered by the user, so what data type is the best to store such info?

![core c5 (4).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(4).jpg?raw=true)

## Mappings for Storage

Mappings are used to store data in key-value pairs. Here, mappings store users, posts, and comments:

- **users:** Maps an address to a `User` struct.
- **posts:** Maps a post ID to a `Post` struct.
- **comments:** Maps a comment ID to a `Comment` struct.

**Assignment**: Replace `YOUR_CODE_GOES_HERE` in Line `37` with the correct Struct.

![core c5 (5).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(5).jpg?raw=true)

## Counters for Unique IDs

Counters are used to ensure that each post and comment has a unique ID.

- **postCount:** Tracks the number of posts created.
- **commentCount:** Tracks the number of comments created.

**Assignment**: Replace `YOUR_CODE_GOES_HERE` in Line `43` with the modifier.

I know you’ll get it right! Fill it out!!

![core c5 (6).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/3.%20Writing%20Smart%20Contract%20Basics/core_c5_(6).jpg?raw=true)

> Find the solution to the assignments [here](https://github.com/0xmetaschool/build-social-media-dapp-on-core/blob/solution-to-assigments/contracts/Metacircle_01.sol).
> 

## Push your code

Implement the complete code of the `Metacircle.sol` contract and push it to the `boilerplate01` branch. You can run the following commands.

```
git add .
git commit -m "Done with the implementation of basics in social media dApp"
git push -u origin boilerplate01
```

## Wrap Up

In this lesson, we've explored the basics of our contract and implemented them. We've defined data structures using structs, stored data with mappings, and used counters to manage unique IDs. While this contract forms the foundation, additional functionality and security measures would be needed for a fully operational social media platform on the blockchain. And we will explore that in the upcoming lesson, so stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C5%20Build%20Decentralized%20Social%20Media%20DApp%20on%20Core/2.%20Building%20the%20dApp/3.%20Writing%20Smart%20Contract%20Basics.md

Writing Smart Contract Basics

# User Authentication, Profile, and Post Management

Alright! We've laid the groundwork for our decentralized social media playground, and now it's time to invite the first guests to the party. 🎉 In this lesson, we're diving into the essential steps of user authentication and profile management. Think of it like setting up the bouncer at the door (registration) and giving everyone a cool name tag (profile creation).  We'll unveil the smart contract functions that empower users to create their digital identities, waltz into our dApp, and showcase their unique personalities.

## Setting Up Your Project

First things first, we’ll check out to our right branch. Run the following command to be at the `boilerplate02` branch. Make sure you are in `build-social-media-dapp-on-core` folder.

```
git checkout boilerplate02
```

## Writing Smart Contract

Now we will upgrade our smart contract and add functions to our contract. Just like the previous lesson, we have a few assignments for you to engage you in learning and understanding more to build your dApp. 

Let’s code!

## createUser Function

This function registers a new user on the platform. It checks if the sender (user creating the account) already exists. If not, it creates a new User struct with the sender's address, username, and bio, and stores it in a mapping called "users".

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `43` with the variable that is required to complete a user’s profile. It might be a piece of 🍰 for you.

**Hint:** Well, the hint is it’s the variable that will store the info of the user and it’s also in the parameters of the function. 😉

![core c5 (8).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/core_c5_(8).jpg?raw=true)

## getUsername Function

This function retrieves the username associated with a user's address. It checks if the user exists (has a username stored) before returning the username from the "users" mapping.

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `44` with the necessary keyword.

**Hint:** Hmm, the keyword starts with the alphabet `r` and it will provide the name of the username to its caller. You will get it right in a minute, good luck! 🍀 

![core c5 (9).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/core_c5_(9).jpg?raw=true)

## createPost Function

This function allows a user to create a new post. It first checks if the user creating the post is already registered. If so, it increments a counter keeping track of the total number of posts, creates a new Post struct, assigns it an ID (postCount), sets the author address (msg.sender), stores the post content, and initializes the number of likes to 0. The new post is then stored in a mapping called "posts".

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `60` with the number.

**Hint:** If a post has been created, then what do you think should be the count of likes of that post? I know you know the answer, just it here and we are good to go. 💪🏼

![core c5 (10).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/core_c5_(10).jpg?raw=true)

## Compile and Deploy

Time to test our code by compiling and deploying it.

- First, let’s create a `.env` in the `build-social-media-dapp-on-core` directory and paste your private key against the `PRIVATE_KEY` variable.
    
    ```
    PRIVATE_KEY=""
    ```
    
- Now let’s install all the dependencies and compile our contract using :
    
    ```
    npm install 
    npx hardhat compile
    ```
    
- Let’s deploy our contract using hardhat ignition just like last time
    
    ```
    npx hardhat ignition deploy ./ignition/modules/deploy.js --network core_testnet
    ```
    

> **Make sure to save your contract address as we will need it later.**
> 

## Frontend Interaction: Bringing it to Life

We deserve to see what we have coded in real-life interaction. So let’s see how we can do that:

- First, run the following commands:
    
    ```
    cd interface
    npm install
    cd src
    mkdir ABI
    ```
    
- Copy the `Metacircle.json` file from `artifacts/contracts/Metacircle.sol/`and paste it inside the `interface/src/ABI` folder.
- Navigate to `interface/src/contexts/Web3Context.js` and replace YOUR_DEPLOYED_CONTRACT_ADDRESS with your deployed contract address.
    
    ![core c5 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/core_c5_(2).jpg?raw=true)
    
- Now run the following command to start your dApp. Make sure you are in `interface` folder.
    
    ```
    cd ../
    npm start
    ```
    

### Create your profile

Well connect your Metamask and add your info to complete your profile. Exciting?

![add info .gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/add_info_.gif?raw=true)

### Create Your Post

You can also write your post:

![add post final.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/add_post_final.gif?raw=true)

> Find the solution to the assignments [here](https://github.com/0xmetaschool/build-social-media-dapp-on-core/blob/solution-to-assigments/contracts/Metacircle_02.sol).
> 

## Push your code

Let’s push our changes to the `boilerplate02` branch. You can run the following commands. Make sure you are in the `build-social-media-dapp-on-core` folder.

```

git add .
git commit -m "Done with User Authentication, Profile, and Post Management"
git push -u origin boilerplate02
```

## That’s a Wrap

We've now unlocked the gates to our decentralized social media kingdom! Users can create their own profiles and posts too.

In our next adventure, we'll empower users with more functionalities. Get ready to unleash the true potential of your decentralized social network!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C5%20Build%20Decentralized%20Social%20Media%20DApp%20on%20Core/2.%20Building%20the%20dApp/4.%20User%20Authentication%2C%20Profile%2C%20and%20Post%20Management.md

User Authentication, Profile, and Post Management

# Adding Likes and Comments to Posts

The excitement is building! Our decentralized social media platform is buzzing with activity, and it's time to unleash the full potential of community interaction. In this lesson, we'll complete the core functionality of our dApp by adding likes and comments, along with the necessary functions to retrieve and display this dynamic content. Get ready to witness the power of Web3 as we transform your platform into a vibrant social hub!

## Setting Up Your Project

First things first, we’ll check out to our right branch. Run the following command to be at the `boilerplate03` branch. Make sure you are in `build-social-media-dapp-on-core` folder.

```
git checkout boilerplate03
```

## Smart Contract Deep Dive: The Mechanics of Interaction

Let's continue our exploration of the smart contract functions that empower users to engage with your dApp.

## likePost Function

This function checks if the user exists and if the post exists. If the user hasn't liked the post before, it increments the like count, marks the user as having liked the post, and adds the user's address to the `likedBy` mapping of the post.

**Assignment:** We are back with an easy assignment. Replace YOUR_CODE_GOES_HERE in Line `68` with the variable’s name that will be incremented when the user likes a post. Make sure to increment that variable too.

**Hint:** See the name of the function, it’s part of it 😉👍🏼

![core c5 (3).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/core_c5_(3).jpg?raw=truedd)

## unlikePost Function

Similar to likePost, but checks if the user has liked the post before. If so, it decrements the like count, removes the user from the `likedBy` mapping, and updates the user's liked status.

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `75` with the appropriate variable.

**Hint:** It’s the one who wrote the post. 🤫

![core c5 (4).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/core_c5_(4).jpg?raw=true)

## commentOnPost Function

This function checks if the user and post exist. If so, it creates a new Comment struct, assigns it an ID, and sets the author's username, post ID, and content. Then, it adds the comment ID to the post's `commentIds` array.

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `90` with the appropriate variable.

**Hint:** Well it’s the info that the commenter wants to write on post. 📝 And it’s also one of the parameters of the function.

![core c5 (5).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/core_c5_(5).jpg?raw=true)

## Checking Post and User Status

**isPostLikedByUser:** This function checks if a specific user has liked a post.

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `99` with the appropriate variable.

**Hint:** Well it’s one who wants to like the post. 📝 And it's also one of the parameters of the function.

![core c5 (6).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/core_c5_(6).jpg?raw=true)

- **isUserRegistered:** Checks if a given address corresponds to a registered user.
- **getPostAuthorUsername:** Retrieves the username of the post's author.

![core c5 (7).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/core_c5_(7).jpg?raw=true)

## getCommentsForPost Function

This function retrieves all comments associated with a given post. It iterates through the post's `commentIds` array and fetches the corresponding Comment structs from the comments mapping.

**Assignment:** Replace YOUR_CODE_GOES_HERE in Line `120` with the appropriate variable.

**Hint:** It’s the count of comments for a post. Did we initialize an array for that in the function? Check that out!

![core c5 (8).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/core_c5_(8).jpg?raw=true)

## Compile and Deploy

Time to test our code by compiling and deploying it.

- First, let’s create a `.env` in the `build-social-media-dapp-on-core` directory and paste your private key against the `PRIVATE_KEY` variable.
    
    ```solidity
    PRIVATE_KEY=""
    ```
    
- Now let’s install all the dependencies and compile our contract using :
    
    ```
    npm install 
    npx hardhat compile
    ```
    
- Let’s deploy our contract using hardhat ignition just like last time
    
    ```
    npx hardhat ignition deploy ./ignition/modules/deploy.js --network core_testnet
    ```
    

> **Make sure to save your contract address as we will need it later.**
> 

## Frontend Interaction: It's Showtime!

We deserve to see what we have coded in real-life interaction. So let’s see how we can do that:

- First, run the following commands:
    
    ```
    cd interface
    npm install
    cd src
    mkdir ABI
    ```
    
- Copy the `Metacircle.json` file from `artifacts/contracts/Metacircle.sol/`and paste it inside the `interface/src/ABI` folder.
- Navigate to `interface/src/contexts/Web3Context.js` and replace YOUR_DEPLOYED_CONTRACT_ADDRESS with your deployed contract address.
    
    ![core c5 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/4.%20User%20Authentication,%20Profile,%20and%20Post%20Management/core_c5_(2).jpg?raw=true)
    
- Now run the following command to start your dApp. Make sure you are in `interface` folder.
    
    ```
    cd ../
    npm start
    ```
    

Now while the smart contract is the backstage crew, the frontend of your dApp is the dazzling stage where the action unfolds.

Let’s see if we can comment on any post! Try it and let us know!!

![comment FINALLL.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/comment_FINALLL.gif?raw=true)

And like a post too!

![like post.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/core-c5-build-decentralized-sm-dapp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts/like_post.gif?raw=true)

Experiment with the frontend and try to dislike the post, comment, like, post and see what happens!

> Find the solution to the assignments [here](https://github.com/0xmetaschool/build-social-media-dapp-on-core/blob/solution-to-assigments/contracts/Metacircle_03.sol).
> 

## Push your code

Let’s push our changes to the `boilerplate03` branch. You can run the following commands. Make sure you are in the `build-social-media-dapp-on-core` folder.

```
git add .
git commit -m "Decentralized Social Network is Alive"
git push -u origin boilerplate03
```

## Wrap-Up: Your Decentralized Social Network is Alive!

🎉  High-fives all around! You've successfully added the essential ingredients of likes and comments to your decentralized social media platform. Users can now not only share their thoughts but also express their appreciation and engage in lively conversations. Your dApp is buzzing with the potential for meaningful connections and vibrant community interactions.

Congratulations on completing this exciting journey! You've built a powerful foundation for a more open, transparent, and user-centric social media experience. Now, go out there and let your creativity soar as you explore the endless possibilities of Web3 development! 🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C5%20Build%20Decentralized%20Social%20Media%20DApp%20on%20Core/2.%20Building%20the%20dApp/5.%20Adding%20Likes%20and%20Comments%20to%20Posts.md

Adding Likes and Comments to Posts

# Wrap 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. Let's summarize what you've learned till now.

## Building the Decentralized Social Media dApp

One of the most interesting parts of the course was that we built our very own Decentralized Social media dApp! We created functions to create posts, like, dislike, and comment on them - exactly how it is done in traditional social media dApp.

## Deploy and Interact with Contract

Another super interesting part filled with learning, was when we deployed a contract on Core and interacted with it through frontend. And that’s how we built a full-fledged project which not only creates a contract but also interacts with it through our frontend.  

## ⚒️ A small yet important request

Here is great news for you! 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). If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://bit.ly/core-course-discord) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our [repository](https://github.com/0xmetaschool/Learning-Projects). 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/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn) as well. 🫶
3. Subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos.

Also, now that you have a strong understanding of Core, Why don't you take the next step and become an active participant in the Core ecosystem? Here's how you can get involved and make your mark:

1. Join their [Telegram channel](https://t.me/CoreDAOTelegram), [Discord channel](https://discord.com/invite/coredaoofficial).
2. Follow Core Chain on [X](https://twitter.com/Coredao_Org), [X account for Devs](https://x.com/corechain_devs), and subscribe on the [YouTube](https://www.youtube.com/@Core_DAO_Official) channel.
3. Contribute directly to the CoreDAO [Github Repository](https://github.com/coredao-org).

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the in-depth knowledge to start building in the exciting world of Core. We wish you luck!

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C5%20Build%20Decentralized%20Social%20Media%20DApp%20on%20Core/3.%20Let%E2%80%99s%20Wrap%20It%20Up/6.%20Wrap%20Up.md

Wrap Up

Build Decentralized Social Media DApp on Core

Core is a groundbreaking blockchain that seamlessly merges Bitcoin's robust security with the flexibility of smart contracts. This comprehensive course will delve into Core’s unique Satoshi Plus consensus, which harnesses the power of both Bitcoin miners and CORE token holders. You will learn how Bitcoin holders can stake their BTC to earn CORE tokens, fueling the future of Bitcoin-powered DeFi. Also, explore the diverse range of dApps built on Core and gain a deeper understanding of its potential to revolutionize the DeFi landscape.

# What are we learning today?

Hello everyone ☀️

Exciting news: we're kicking off our first-ever course on Core blockchain’s learning track at Metaschool! Core is all about leveling up security, decentralization, AND scalability. We are super excited to have you with us on this journey to learn and build on Core!

Btw, following official github repos of blockchains and interacting with it is a great idea. Blockchains airdrop and consistently reward their followers. Do follow Core [here](https://github.com/coredao-org).

So, Why Core? At the time of writing, Core has already hit [258M+ transactions on-chain](https://scan.coredao.org/) and [5M active wallets](https://scan.coredao.org/chart/active-address). Not only this, it has a strong community of [267k discord members](https://discord.com/invite/coredaoofficial) and a strong following on [X of 2.3M.](https://x.com/Coredao_Org)

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcJDNqFGMaDaNzvHfFuGu-jz6rO32k1uiFM3UHFFrWp2z1uwC-5BIA1aiQzHX636mSgmwNCZCn2s58A8niPwa43gHqFkHkGXJUNpnNNTbO-dMTUdCZKW7BFMkOMpnjHCU4-Fwvaqk3cKyvnQg3u7eSUZuNj?key=7jxxoZbU2J8q5A8ybAThPg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L1%20P1.png?raw=true)

Another exciting aspect is that Core is the world’s first most Bitcoin-aligned Layer 1 blockchain, meaning it leverages Bitcoin's robust security while also offering smart contract functionality. This allows Bitcoin holders to stake their coins and earn passive income, while also opening up a world of possibilities for building decentralized applications on the blockchain. Yep! I hear you, they are pretty dope and we don’t want you to miss out on them.

But hold your horses before you hit that next button! Let's quickly take a peek at what's in store and what goodies you'll take away from this course.

## Course Overview

We will:

1. Introduce you to Core’s mission, vision, and values
2. Learn how Core helps to unlock the $1T trapped in Bitcoin liquidity
3. Deep dive into Core’s underlying technology
4. Understand Satoshi Plus Consensus Mechanism
5. Explore the developer tools Core has partnered with to smoothly onboard users to the web3
6. Explore important dApps on the Core ecosystem

## Who exactly should take this course?

Core learning track is for blockchain enthusiasts excited to know how Core brings Bitcoin empowerment and EVM compatibility together and for the peeps who want to contribute to the Core ecosystem.

## What will you be getting out of this course?

You will be getting the following outcomes when you complete this course:

1. Understanding of Core’s mission, technology, and ecosystem
2. Building dApps secured by Bitcoin on Core
3. Get yourself ready for the next course in the series
4. Claim your NFT on course completion

## Proof of completion

If you complete this course, you will get a special NFT, a utility token, which will unlock many more opportunities on the Metaschool platform. Here is what the NFT looks like.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfeYlZOy6z8pMuKqgjONArtSrf9ohaUviGk_DAb1jopx7lLj6FFlXbbKiB7b3bb21waeP4_9z7-zglq2baHE5lG6KtDddED4DDUoi8PwK4JUDYJVu4XyoizfNQ2jruuDBJlHnrDG3UN76o-xIDA6nK_zBVL?key=7jxxoZbU2J8q5A8ybAThPg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L1%20P2.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://bit.ly/core-course-discord) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [Github](https://github.com/0xmetaschool), it would be a great support. 🫣
4. Stay happy and positive!

Alright guys, no need to wait any longer. Let’s get started!!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/1.%20Getting%20Started%20with%20Core%20/Lesson%201%20-%20What%20are%20we%20learning%20today.md

What are we learning today?

# Introduction to Core

Hey there, blockchain enthusiasts! Ever wondered what happens when you mix Bitcoin's bulletproof armor with EVM compatibility? Get ready to geek out, because we're about to dive into the mind-blowing world of Core. It's a blockchain that's shaking up the Web3 scene and promising a whole different world of possibilities. So grab your explorer hats (or VR headsets, we don't judge), and let's dive into this game-changer together!

## Overview of Core

Core is the world's first most Bitcoin-aligned layer-1 blockchain, merging Bitcoin's robust security with Ethereum's smart contract flexibility. Being "Bitcoin-aligned" means that Core leverages Bitcoin's principles and security through its unique Satoshi Plus consensus mechanism, which combines Delegated Proof of Work (DPoW) from Bitcoin miners with Delegated Proof of Stake (DPoS) that brings together the power of CORE holder and BTC holders through the ground-breaking feature of Non-Custodial BTC Staking. This innovative approach enhances security, expands Bitcoin miners' utility by incorporating them into the security of Turing-complete smart contracts, and provides miners with supplemental income in the form of CORE token rewards. As a result, Core unlocks a new realm of possibilities for developing complex smart contracts and decentralized applications.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdEnAmj8-NhkLgkIrMe3gaKIPdDsqE9GXL2kQgpjU1YDeKkf9BIZGKCQwwN4irjv8Y3TwyjvwFhhp0RnjlMIwgSBcij_1poE0OnJeujDu5PMhR_qMVMQmn0cxhNLFELHZuda1G0xBA6TRyNxN9yfWQPhcIR?key=CjNbRn5FixD4uptj96esfQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L2%20P1.jpeg?raw=true)

Let’s see what makes Core special…

### Core: The Dream Team of Blockchain Innovation

Think of Core as a team of brilliant minds on a mission. They're not just building another blockchain; they're on a quest to create something truly unique. Their vision is to merge the legendary security of Bitcoin, with the flexibility and innovation of Ethereum, the platform that gave birth to decentralized applications (dApps).

Why bring these two powerhouses together? Well, Bitcoin is like a fortress, virtually unhackable due to its robust proof-of-work consensus mechanism and vast network of miners. Meanwhile, Ethereum is a bustling city of innovation, where developers build amazing applications using smart contracts. Core wants to combine these strengths, creating a blockchain that's both secure and versatile enough to support the next generation of dApps.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXc6U4SPfb1xr1fNvrL0gSt4Xa81B-isvoH_TCFMCBgxp6JmcWZBxL0ETS_KhlrH9rT7zDBwm9zIuSi26yTcTx-dM1sDNyGpSCgHIPRtVXf3QwqXP2NfCqcY9NF1yfcPJRYrYgGq4R_vd_1xP8mM-q3gC_E?key=CjNbRn5FixD4uptj96esfQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L2%20P2.gif?raw=true)

Imagine a world where you can use decentralized financial tools that are as secure as Bitcoin or create NFT marketplaces that can handle millions of transactions without breaking a sweat. That's the kind of future Core is envisioning.

## Features of Core

Here are Core's key features that tell how it is ahead of its competitors:

![https://lh7-us.googleusercontent.com/docsz/AD_4nXf5ulPwrEgFlDcoAzMRUbm_EfkQEoJfnaTkzptBZ2G99QZM_vGtfS7RDMCy4o3vlSwiO1hwt68m4lQVJfB_xUtAFqIT_Xjy7hZt7jCud6GYiDkLn50rdxID9XVPE4vlHAYPS1zNEwzEvbzwGcIxCd-dqx2I?key=CjNbRn5FixD4uptj96esfQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L2%20P3.gif?raw=true)

- **Satoshi Plus Consensus Protocol:** This innovative consensus mechanism combines the security of Bitcoin's Delegated Proof of Work (DPoW) with the efficiency of Delegated Proof of Stake (DPoS) and the uniqueness of Non-Custodial BTC Staking. This three-layer approach ensures robust network security while incentivizing participation through staking rewards for both CORE and Bitcoin holders.
- **EVM Compatibility:** Core is fully compatible with the Ethereum Virtual Machine (EVM). This allows existing Ethereum-based applications to seamlessly run on Core, opening up a vast ecosystem of dApps and tools for developers and users.
- **coreBTC:** This is a representation of Bitcoin on the Core, enabling Bitcoin holders to participate in Core’s decentralized finance (DeFi) ecosystem. Think of it as a bridge between Bitcoin and the world of DeFi.
- **CORE Staking:** By staking CORE tokens, users actively contribute to the network's security and governance while earning rewards. Staking CORE is a way to support the Core ecosystem and earn passive income.
- **Non-Custodial BTC Staking:** Core introduces a novel way to earn rewards by staking Bitcoin without giving up custody of your assets. This is facilitated by "Hashed Timelock Contracts" (HTLCs), unlocking new possibilities for utilizing Bitcoin in DeFi applications on Core.
- **stCORE:** stCORE is a liquid staking derivative of CORE, representing staked CORE tokens on the Core. It allows users to earn staking rewards while still maintaining liquidity and the ability to use their stCORE in DeFi applications.
- **HTLC Atomic Swap:** This feature enables trustless cross-chain swaps between different assets, leveraging HTLCs to ensure the atomic exchange of assets across different blockchains. This enhances interoperability and expands the possibilities for decentralized trading and asset exchange.

These features make Core stand out because they combine security, ease of use, and new ways to leverage Bitcoin's value.

## Primary Goal and Why Core?

Core aims to establish itself as a leading blockchain platform by offering a unique blend of features that address the limitations of existing blockchains. By leveraging Bitcoin's security, ensuring decentralization through Satoshi Plus consensus mechanism, and providing a robust security model, Core creates a reliable and trustworthy environment for developers and users alike.

Let’s see some of the major characteristics that set Core apart from its competitors:

- **Leveraging Bitcoin's security:** Core utilizes Bitcoin security by letting miners delegate their hash power to validators on Core, earning CORE tokens. Also, through BTC staking, BTC holders can earn passive income in the form of CORE tokens.
- **Ensuring decentralization through Satoshi Plus**: Core's decentralization is ensured by the unique Satoshi Plus consensus mechanism. This innovative system combines three distinct layers:
- **Bitcoin miners** contribute by leveraging their existing Bitcoin hash power to secure the network.
- **CORE token holders** participate in governance through staking and voting, allowing for community-driven decision-making.
- **Non-custodial BTC staking** enables Bitcoin holders to contribute to the network's security while earning rewards, all without relinquishing control of their assets.


  This three-layer system combines the established security of Bitcoin's proof-of-work, the flexibility of delegated proof-of-stake for CORE token holders, and the added security and incentives of Non-Custodial BTC Staking to promote decentralization and security within the Core ecosystem.

- **Robust security model:** Core’s security relies on robust decentralization (DPoW, DPoS and Non-Custodial BTC Staking) and a strong security model that rewards identifying and punishing malicious nodes.
- **High scalability:** Core is designed with scalability in mind. While its Satoshi Plus consensus mechanism incorporates elements of Delegated Proof of Stake (DPoS) for CORE token holders, the system also leverages Bitcoin's proof-of-work and allows for Non-Custodial BTC Staking. This unique combination aims to support a greater number of validators and enable future scaling solutions. While the full impact of Satoshi Plus on scalability is still being realized, the network's architecture aims to adapt to the increasing demands of the blockchain ecosystem.
- **Permissionless participation:** Core is permissionless, allowing anyone to participate and build without needing approval. Its decentralization, open-source code base, and consensus model ensure this openness forever.
- **Community-governed ecosystem:** Core is a community-governed blockchain, with the Core DAO playing a central role in its governance. It strives to balance fixed and flexible elements within its protocol. As the network scales and participation grows, the Core DAO will increasingly empower CORE token holders to vote on protocol changes, solidifying its commitment to decentralization and community governance.
- **Interoperability across blockchains:** Core Chain revolutionizes blockchain interoperability through its pioneering Non-Custodial BTC Staking feature, empowering Bitcoin holders to leverage their assets on Core Chain without relinquishing control over their original holdings. This innovation, combined with Ethereum Virtual Machine (EVM) compatibility, enables seamless integration and porting of Ethereum-based protocols, while fostering cross-chain communication. This unique synergy not only expands the possibilities for Bitcoin utilization but also contributes to a more interconnected and accessible blockchain ecosystem.
- **Composability for versatile applications:** Core achieves composability through Solidity, the popular smart contract language. Developers can create contracts that interact seamlessly, enabling peer-to-peer borrowing, lending, liquidity pools, trading platforms, and more.

## Wrap Up

We covered that Core is a revolutionary blockchain that achieves Bitcoin's security without compromising on scalability. This creates a fast, secure, and scalable platform for the next generation of DeFi applications. Well in the next lesson, we will cover the components of Core. So stay tuned!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/1.%20Getting%20Started%20with%20Core%20/Lesson%202%20-%20Introduction%20to%20Core.md

Introduction to Core

# Components of Core

Welcome back, crypto explorers! We've just explored the features and primary goal of Core, which combines Bitcoin's rock-solid security with the flexibility of smart contracts to create a powerful DeFi platform. Now, get ready to dive deeper into the heart of this revolutionary technology. Let's unravel the mysteries of Satoshi Plus, the groundbreaking and innovative consensus mechanism that powers Core, and explore the key roles that keep the ecosystem running smoothly. This is where the real adventure begins! So why wait, let’s dive right into it!

## Introduction to Satoshi Plus Consensus Mechanism

Core's power lies in its unique consensus mechanism, Satoshi Plus, a multifaceted approach that revolutionizes the blockchain landscape by seamlessly integrating the best of Bitcoin and Ethereum's technological advancements. This innovative mechanism has three fundamental components, each contributing to a secure, efficient, and decentralized blockchain ecosystem:

- **Delegated Proof of Work (DPoW):** This is where Bitcoin's immense computing power comes into play. Bitcoin miners, who are constantly working to secure the Bitcoin network, can also lend their strength to the Core network, acting as security guards for this new city, without needing to invest in any extra equipment or resources. This not only makes Core more secure but also provides an additional income stream for Bitcoin miners in the form of CORE tokens.
- **Delegated Proof of Stake (DPoS):** This is where you, the everyday crypto holder, can get involved. By staking your CORE tokens (Core's native currency) or even your Bitcoin, you're essentially vouching for the credibility of certain "validators." These validators are responsible for processing transactions and maintaining the blockchain's integrity. The more tokens staked with a validator, the more likely they are to be elected to do this important work. It's like a democratic election where your vote matters, but in this case, your vote is backed by your financial stake in the network.
- **Non-Custodial BTC Staking**: Here's where Core truly stands out. It is the first and only blockchain to offer a groundbreaking feature called Non-Custodial BTC Staking. This unique innovation sets Core apart from other blockchains by allowing Bitcoin holders to stake their BTC directly on Core without relinquishing control of their assets. It's like earning interest on your savings without having to deposit your money in a bank. You get to actively participate in the Core ecosystem, earn rewards in CORE tokens, and still retain full ownership and control over your Bitcoin. It's a win-win scenario for both Bitcoin holders and the Core network, as it enhances security while providing a new way for Bitcoin holders to put their assets to work.

![image-depicting-satoshi-plus-consensus-mechanisms](https://lh7-us.googleusercontent.com/docsz/AD_4nXdWPzKcGRG1cDexRqh9WFdgsv2whcvLbRoM2wFlunC3Vhnj4Ru1Qo06rer-gPO654KoNsfpObi10BNUTavivTu5RJPlU1eq8nnhHv4EsRIh1BB59S3OHIzKtVT7oR5p6D9wp7G0_pzhJOMAKN9RqRZmd6ah?key=XwfQlAVgRWlAFTMMIstIaQ)

## Major Components and Roles

Core is more than just a technology; it's a vibrant ecosystem with diverse key roles:

- **Validators:** They are the heart of Core ecosystem, responsible for processing transactions and maintaining the blockchain's integrity. They are elected based on a combination of community trust (staked CORE and Bitcoin) and technical capability (delegated hash power). Think of them as the city council, chosen for their experience, reliability, and popularity.
- **Verifiers:** These are the network's watchdogs, ensuring that validators are doing their job correctly. They monitor the network for any suspicious activity and report any issues they find, just like vigilant citizens who keep an eye on their elected officials.
- **Relayers:** These specialized nodes are crucial for connecting the Bitcoin and Core blockchain. They monitor the Bitcoin blockchain for events relevant to Core, such as Bitcoin deposits for minting coreBTC or Bitcoin transactions for releasing staked Bitcoin. Relayers then submit cryptographic proofs of these events to Core, ensuring the trustless and secure movement of assets between the two chains.
- **CORE token Holders:** The community members who hold CORE tokens and actively participate in the network's governance through staking and voting. They're the voters who have a direct say in how the city is run.
- **Bitcoin Holders:** They can participate in the Core ecosystem by staking their BTC, earning rewards, and contributing to the network's security.
- **Bitcoin Miners:** By lending their computing power to Core’s validators, they contribute to the network's security and earn a share of the rewards. They're like the city's security forces, protecting it from external threats while getting paid for their services.

![image-depicting-major-components-and-roles](https://lh7-us.googleusercontent.com/docsz/AD_4nXeetr48_maOZVQazGBCw7MAxjEGX0XVVTQhbegTJdT-h1X5nmqpjBwMGlAXpm-0YSQx7F7tWmVmE_meM0wLi_WDCMmQAsqN-HgQiMorDH72ClSTLWO9JL8EwDmUCj7b4cXQAxRC0Gm9dB66VrlK6YewRyEF?key=XwfQlAVgRWlAFTMMIstIaQ)

## Bitcoin Alignment: Honoring the Original Vision

Core isn't just about creating a new blockchain; it's about staying true to the original vision of Bitcoin. Core is committed to upholding the principles of decentralization, security, and open access that Bitcoin embodies. By leveraging Bitcoin's security and involving the Bitcoin community, Core strives to build a bridge between the past and future of Blockchain interoperability. Think of it as building a high-speed rail network that connects Bitcoin, the established city, to the new and innovative city of Core, facilitating trade and collaboration between them.

## Wrap Up

Alright, crypto explorers, we've just scratched the surface of the Core ecosystem. Focusing on both security, scalability and fostering a truly inclusive community, Core is paving the way for a more decentralized, robust, and innovative future. But what were the exact events that led to the creation of this revolutionary blockchain? Let's journey back in time and explore the history of Core in our next lesson.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/1.%20Getting%20Started%20with%20Core%20/Lesson%203%20-%20Components%20of%20Core.md

Components of Core

# The History of Core

Hey there Developers! In the last chapter, we gave you a sneak peek into the Core blockchain. Now, as blockchain enthusiasts, we know you guys are super pumped to start the building part, but as the Developer's code of conduct would dictate, one should understand the ‘why’ before they get to the ‘how’.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcQV3wiVVkmG81fmn8Hqb3Vqpj0T3aODwi4FUMk4P__IZsHCPNHcCvGOF4siuCiJdxaTmBr5upDX24SDt9Z1aE75MciL_kk4P8TyKpnTfPjPZedn4f4_FZwm2mfCMQk213fzD1J6cLbjLfI6ty27ReUC15J?key=vtLTtJHs5MQqzL6kDiBltQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L4%20P1.png?raw=true)

So, in this lesson, we will be looking into why the Core was conceptualized in the first place. So without further ado, let’s dive into the history of Core.

## Introduction to Blockchain Trilemma

Ready for some truth? No blockchain is perfect. This statement lies at the heart of the Blockchain Trilemma. When designing blockchains, developers often face a trade-off between three key factors: security, scalability, and decentralization. Improving one of these aspects often comes at the expense of the others, hence the Trilemma.

- **Security** is crucial to prevent data compromises and tampered transactions.
- **Scalability** involves handling increasing amounts of transactions without sacrificing speed or efficiency.
- **Decentralization** ensures no single entity controls the network, maintaining trust and resilience

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcUSkSXrmEMCn7m9p_pJoyQ66mH1N6IAO19vRKNhk3CtTmnP_iCgmZ0-avJ0aADsIKV8qSX7O8FnIwfe-qultUoaluoWJUEJ1F2ivklNAWZ5DuZBS1-ymK8EEFem_mos5LkMgQW-qZXrJLn4Dr4j5dqHo0?key=vtLTtJHs5MQqzL6kDiBltQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L4%20P2.png?raw=true)

Every blockchain aims to solve the trilemma, each with its unique features. This trend began with Bitcoin, the original blockchain network.

### Bitcoin & Ethereum: Strengths and Weaknesses

**Bitcoin** excels in security and decentralization using the Proof of Work (PoW) consensus mechanism. Miners validate transactions and generate new blocks by solving complex puzzles, ensuring security, and distributing power. However, Bitcoin struggles with scalability, leading to slower transactions and higher fees during peak usage.

**Ethereum** introduced smart contracts, aiming to be a decentralized world computer. It addressed some of Bitcoin's scalability issues with gas fees and layer 2 solutions. However, as Ethereum scaled, it faced challenges in maintaining decentralization while handling a growing number of transactions.

Today, many blockchain projects offer their solutions to the Trilemma. Some prioritize scalability, sacrificing decentralization. Others focus on decentralization, accepting limitations in scalability and speed. Core blockchain aims for a delicate balance between all three.

## Inception of The Core Project

The origin of Core is essentially one of those rare instances where a debate among friends led to something productive and by productive we mean a thriving blockchain ecosystem. According to an official tweet from Core DAO: Two friends, one an ETH Maxi and another a Bitcoin Maxi were debating the pros and cons of the two blockchains and this sparked the idea to create a blockchain that will carry the best of both chains.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfWCF3hbFWpKzEE-XiQJQ64gI-9eSG6S93PeCf7zlMJnD-_WARR3PrZD2_P1AoHDGghzknopEr7xOmqCo9U4Ea-GiBA2qACVwnRzuuyIy-K8gpRAuy9e8zi0zNjB8yxwyQSrr-J-dMpCK211rZaGHdUB84?key=vtLTtJHs5MQqzL6kDiBltQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L4%20P3.png?raw=true)

Now, in case you are wondering what a Maxi is, they are essentially hardcore supporters of a particular protocol.

Core is a community-driven initiative, developed and maintained by a global network of contributors, many of whom prefer to remain anonymous, as is quite common in the web3 space.

The Core team released the initial testnet on July 29, 2022, and almost 6 months later, on January 14, 2023, the Core mainnet was launched.

Core's codebase is built upon a heavily modified and enhanced version of [Geth](https://geth.ethereum.org/), the Go-language-based implementation of Ethereum. It has leveraged various performance improvements inspired by projects like BNB Smart Chain (BSC) to achieve high throughput and reduce transaction costs.

However, Core differentiates itself significantly through its unique consensus mechanism called Satoshi Plus. This algorithm combines Bitcoin's [Proof of Work (PoW)](https://ethereum.org/en/developers/docs/consensus-mechanisms/pow/) with a [Delegated Proof of Stake (DPoS)](https://en.bitcoin.it/wiki/Delegated_proof_of_stake) system and Non-custodial BTC Staking. Through this, it addresses the scalability and energy concerns of traditional PoW while preserving the decentralization that is fundamental to blockchain technology.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXchmewK1XreTp_2LF7XB6naC3yflCYQGAsVqyuScPKceYufbbsiraivpbtk-04H3ycGXcbXQmpjilxciw64Bdb5LOP65_dUzpZ7TR-FVzBfjiclu5ifq1J6X9Ue507jB872AjuturXbcvPmS4TJ9Cq_8JZf?key=vtLTtJHs5MQqzL6kDiBltQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%201%20images/L4%20P4.png?raw=true)

Furthermore, Core introduces a novel hybrid score system, which factors in delegated Bitcoin hash power (PoW), delegated stake in the form of CORE tokens (DPoS) and delegated BTC through the Non Custodial BTCs staked, to determine validator selection and reward distribution. This approach aims to create a more equitable and accessible validator ecosystem. But more on that later.

For now, just understand that Core isn't just a remix of existing ideas. It brings forth its unique blend of innovations and ideas that takes it much closer to cracking the blockchain trilemma. And makes Core stand out from the rest of the Blockchain crowd.

## How does Core Tries To Solve The Trilemma

Core's innovative Satoshi Plus consensus mechanism directly addresses the blockchain trilemma, achieving an unprecedented balance of security, scalability, and decentralization. By integrating Bitcoin's robust Proof of Work security model with the efficiency of Delegated Proof of Stake, and the innovative Non-Custodial BTC Staking mechanism, Core ensures both a high level of protection against attacks and rapid transaction processing. This unique combination not only enhances the overall security and efficiency of the network but also empowers Bitcoin holders to actively participate in the Core ecosystem while retaining full control of their assets.

Core's compatibility with the Ethereum Virtual Machine (EVM) further enhances scalability by allowing for the integration of Ethereum's cutting-edge scaling solutions. Moreover, the unique hybrid score system for validator selection, which combines Bitcoin hash power and CORE/BTC token staked, fosters a more equitable and decentralized network, preventing the concentration of power among wealthy stakeholders. This commitment to decentralization is further solidified by Core DAO's community-driven governance model, empowering CORE token holders to actively participate in decision-making processes.

## Problems Addressed by the Core Blockchain

With all this fancy tech under the hood, Core aims to tackle major issues in the blockchain space and redefine interaction with this technology:

- **Scalability and Security:** Satoshi Plus balances scalability, security, and decentralization, allowing faster and cheaper transactions without sacrificing security.
- **Decentralized Governance and Community Participation:** Core emphasizes community involvement in decision-making processes. Through staking and voting mechanisms, individuals can actively participate in shaping the future of the network.
- **Permissionless Innovation:** Core is open to everyone. Bitcoin holders can earn passive income by staking their BTC, while developers can build innovative dApps on the platform. This creates a vibrant and inclusive ecosystem that benefits all participants.
- **Unlocking Bitcoin's Potential:** Core enhances Bitcoin's functionality by providing additional revenue streams for Bitcoin miners, maximizing Bitcoin's utility and value.

## **Wrap Up**

Alright! We've covered a ton about the Core’s history and its innovative approach to the blockchain trilemma. There's still much more to explore. In the coming lessons, we'll delve deeper into Core's inner workings, including its consensus mechanism, governance model, and the roles of different participants. Buckle up and get ready to discover the exciting world of Core!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/1.%20Getting%20Started%20with%20Core%20/Lesson%204%20-%20The%20History%20of%20Core.md

The History of Core

# Deep Dive into Satoshi Plus Consensus

Well..Well..Well, look at you, all fired up and ready to roll! It feels like just yesterday we were starting this Core blockchain journey together, and now you're diving deep into the nitty-gritty of the network. Good on ya! But hey, before we get too carried away, let's make sure we're all on the same page with the basics. Take a breather, maybe revisit our last lessons, and refresh your memory on the Core network's different moving parts. It's all about building that solid foundation!

All good? Awesome! Then let's dive right in and discuss one of the Core elements of the Core Network (Get it!)

## Understanding Satoshi Plus Consensus Mechanism

Satoshi Plus is a cutting-edge consensus mechanism, think of it like the engine that drives the Core ecosystem. What makes it so special? It's a hybrid, blending the robust security of Bitcoin's Proof of Work (PoW) with the agility and community spirit of Delegated Proof of Stake (DPoS) and the innovative Non-Custodial BTC Staking. This unique approach creates a blockchain network that's more secure, decentralized, and scalable, setting a new standard for the crypto world.

**The Players in Satoshi Plus: A Team Effort**

Satoshi Plus isn't just a technical concept; it's a collaborative effort involving different groups of participants working together to keep the Core blockchain running smoothly and securely. Now, we have already introduced these components before, Here we will see how they contribute to the functioning of the consensus mechanism:

- **Validators:** Think of validators as the elected officials of the Core community. They're responsible for processing transactions and adding new blocks to the blockchain. They're chosen based on their reliability and commitment to the network's security, and they have to put up a deposit of CORE tokens (the blockchain's native currency) to show they're serious about their job.
- **Delegators:** CORE and Bitcoin holders are the voters in this system. They show their support for validators by "delegating" their tokens to them. The more tokens a validator has staked with them, the more likely they are to be elected. It's a win-win: delegators get a share of the rewards earned by the validator, and the validators get the support they need to secure the network.
- **Bitcoin Miners:** Bitcoin miners, who are already busy securing the Bitcoin network, can also get involved in Satoshi Plus. Through Delegated Proof of Work (DPoW), they can lend their computing power to Core validators, making the Core network even more secure. In return, they get rewarded with CORE token.
- **Relayers:** These participants ensure smooth communication between the Bitcoin and Core blockchain. They're essential for making sure the DPoW process works seamlessly.
- **Verifiers:** Verifiers act as the watchdogs of the network. They monitor validators to ensure compliance with network rules and report any misbehavior, maintaining the network's integrity.

![image-depicting-players](https://lh7-us.googleusercontent.com/docsz/AD_4nXd9Xaf_UKIK-GAGqcl8qQTzHV4qN2Vx6aU1sIzqOQznAIAWRQnZrICjunNndafBCDQo4O-l8YVovasXa0TfCgCYmazu2qANo5NdOtiBwsGyaYw9ZGW1803618cdn0WNiXLVBBebRsUIcu5HpmW3Q3VsFszQ?key=oiHupD-8TbB9THA6lSU9eA)
[comment]: (https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L5%20P1.png?raw=true)

## How DPoW Works in Satoshi Plus

Core leverages the Delegated Proof of Work (DPoW) through its consensus mechanism for creating a powerful synergy between the Bitcoin and Core networks. Bitcoin miners, who are already securing the Bitcoin blockchain with their immense computing power (hash power), can extend their influence to the Core network by signalling their support for specific validators. This is achieved by including a special endorsement message in the coinbase transaction of the Bitcoin blocks they mine. The coinbase transaction is essentially the first transaction in a bitcoin block and the message embedded in that transaction acts as a vote of confidence for the chosen validator.

Relayers on the Core blockchain continuously monitor the Bitcoin blockchain for these endorsements. When they detect an endorsement, they submit proof of this endorsement to the Core blockchain. This proof is then used to determine the likelihood of a validator being selected to create new blocks on the Core blockchain. The more endorsements a validator receives from Bitcoin miners, the higher their chances of being selected.

![image-depcting-how-dpow-works](https://lh7-us.googleusercontent.com/docsz/AD_4nXcB9Gdk4OYKZm87a5tmY1xeZshZ-WR66qPU0C9nPCJmEtMxPa3qKI2Ac9wYQUridtNSjGqZb-wuej6nW0va5x5R35Kc0gA8fvZR9oEV5LyZT5YM1Qy_Di7jHeXGTMcTzXfUlnK37ajQ4oOXigJgNUd2uS8?key=oiHupD-8TbB9THA6lSU9eA)
[comment]: (https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L5%20P2.gif?raw=true)

This system not only enhances Core's security by leveraging Bitcoin's established hash power but also provides Bitcoin miners with an additional source of income in the form of CORE tokens. It's a mutually beneficial relationship that strengthens both networks and fosters a collaborative environment for the growth of the broader blockchain ecosystem.

## How DPoS Works in Satoshi Plus

DPoS is all about giving the community a voice and control over the Core network. CORE token holders get to choose who they want to run the network by staking their tokens with their preferred validators. This is like voting in an election – the more votes (or staked tokens) a validator gets, the more likely they are to be elected to the active validator set.

![image-depcting-how-dpos-works](https://lh7-us.googleusercontent.com/docsz/AD_4nXeshQ8gSvqxs5lMM29BgzWm223DzHanlG2Q1vbJLPV2BmhCnzdWqYnjF40byLWvxy1dlH7eUrdfb1YZfvjJPUcCJaVS6jOzKuoA9M4kGjxiTjPK72euOrEocaowVKF6S1gGgoN5xK63J-KBmzhRAO2SZbc_?key=oiHupD-8TbB9THA6lSU9eA)
[comment]: (https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L5%20P3.gif?raw=true)

**Benefits of DPoS**

This staking mechanism gives token holders a direct say in the network's decision-making and aligns the interests of validators with those of the community. Validators are motivated to act honestly and maintain the network's health to attract more stakes and secure their position in the active set. This creates a virtuous cycle of accountability, transparency, and trust, where the community actively participates in shaping the future of the Core network.

## Understanding Non-Custodial BTC Staking

One of the most innovative aspects of Satoshi Plus is the Non-Custodial Bitcoin (BTC) Staking. It allows Bitcoin holders to join the Core Ecosystem without giving up control of their precious BTC. Instead of handing over their Bitcoin to a third party, users leverage a Bitcoin-native cryptographic feature called "absolute time locks." This is like setting a timer on your Bitcoin, locking it up for a specific period to prove your commitment to the Core network. This time-locked transaction doesn't move the BTC from your wallet but creates a representation of it on the Core blockchain. This representation, though not a separate token like wrapped Bitcoin on other chains, acts as your ticket to participate in Core's decision-making process and earn rewards in CORE tokens.

![image-depcting-how-nonCustodialBtc-works](https://lh7-us.googleusercontent.com/docsz/AD_4nXeKKV8IV6ltwB8CcJIkvLhMuVc31upWxq247vL1IN5FDEsVyJF7UDdMGhhShdhmZBrENwWmscTnTjmpia8pH3_Pze5iBucO_4dNt37mifA2SCm1ulqGing_q8McHTNgYgkHnmuBIwrU-E8UwstMyMhAxig?key=oiHupD-8TbB9THA6lSU9eA)
[comment]: (https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L5%20P4.png?raw=true)

The beauty of this system is threefold:

- **Security and Decentralization:** By attracting both Core and Bitcoin communities to participate in staking and validation, the network becomes more secure and resistant to centralization.
- **Passive Income for Bitcoin Holders:** Bitcoin holders can earn rewards by staking their BTC on Core, providing a new avenue for passive income without sacrificing ownership of their assets.
- **Inclusivity and Diversity:** By lowering the barriers to entry for both BTC and Core token holders and miners from different blockchains, Core creates a more diverse and inclusive ecosystem.

It's a win-win-win scenario that showcases the power of blockchain innovation and opens up exciting new possibilities for both Bitcoin and the Core network.

### What is the Hybrid Score

The hybrid score is the ultimate report card for Core validators. It's a comprehensive evaluation that takes into account three key factors:

1. **Staked CORE:** This reflects the trust and support from CORE token holders, showing which validators the community believes in.
2. **Staked Bitcoin:** This shows the broader cryptocurrency community's faith in the Core network and its validators.
3. **Delegated Hash Power:** This measures the security contribution from Bitcoin miners, indicating the level of support from the Bitcoin network.

Think of the hybrid score as a combination of popularity, trustworthiness, and security contributions. The validators with the highest scores get the privilege of securing the network and earning rewards, ensuring that the most capable and reliable individuals are in charge. In the next chapter, we will dive deep and see how the hybrid score is actually calculated.

## How Satoshi plus consensus ensures security, decentralization, and scalability

Through its innovative Satoshi Plus consensus mechanism, Core aims to tackle the blockchain trilemma – the challenge of achieving scalability, security, and decentralization simultaneously –. This hybrid approach combines Bitcoin's battle-tested Proof of Work (PoW) with a Delegated Proof of Stake (DPoS) system and the novel Non-Custodial BTC Staking feature.

**Security:**

- **Bitcoin-Level Protection:** Core inherits the unparalleled security of Bitcoin's Proof of Work (PoW) system, widely considered the gold standard in blockchain security. This provides Core with robust protection against attacks and ensures the integrity of its data.
- **Double the Defense:** Bitcoin miners actively contribute to Core's security by delegating their hash power to Core validators. This creates a double layer of security, making it exponentially harder for malicious actors to disrupt the network.

**Scalability:**

- **Efficient Transaction Processing:** Core leverages Delegated Proof of Stake (DPoS) to achieve superior scalability compared to traditional Proof of Work (PoW) blockchains. With DPoS, a select group of validators efficiently processes transactions, resulting in faster block times and higher throughput. This enables Core to support a growing ecosystem of decentralized applications while maintaining optimal performance, ensuring seamless user experiences even as demand increases.
- **Ethereum-Powered Scaling:** Core Chain's full compatibility with the Ethereum Virtual Machine (EVM) opens the door to leveraging Ethereum's extensive array of scaling solutions.

**Decentralization:**

- **Leveling the Playing Field:** Core's hybrid score system combines delegated Bitcoin hash power (PoW) and delegated CORE and BTC stake (DPoS) to determine validator selection. This approach ensures that validator power is not solely concentrated in the hands of the wealthiest stakeholders, creating a more equitable and decentralized network where smaller players can actively participate.
- **Community-Driven Decision Making:** Core DAO embraces a community-driven governance model, empowering CORE token holders to propose and vote on changes to the network. This ensures that the network's development is guided by the collective will of the community, preventing any single entity from exerting undue influence.

## Wrap up

Alright, team, we've just scratched the surface of the Core network and its revolutionary Satoshi Plus consensus. We've met the key players and seen how they work together to keep the blockchain humming. But the real magic lies in how these players collaborate to make decisions and secure the network. Ever wondered how the validators, the ones in charge of processing transactions and adding blocks to the chain, are actually chosen? Get ready, because in the next chapter, we'll be taking an in-depth look into all that! So, Let's go!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/2.%20Understanding%20Core%E2%80%99s%20Architecture/Lesson%205%20-%20Deep%20Dive%20into%20Satoshi%20Plus%20Consensus.md

Deep Dive into Satoshi Plus Consensus

# Core Workflow

Alright, grab your popcorn and get ready for the main event! In the last lesson, we explored the inner workings of the Satoshi Plus algorithm, and now it's showtime! Let's see how Core puts this clever contraption to work to elect its very own validators. We will also delve into the rewards given to these validators for keeping the network humming and how these rewards are dished out.

## Overview of how Core functions

Ever wondered how Core blockchain actually works? It's a dynamic collaboration, a well-orchestrated performance with these lead roles: Bitcoin miners, CORE/BTC holders/stakers, and validators.

On one side, we have the Bitcoin miners, the powerhouse of the operation. They contribute their raw computing power, also known as hash power, to safeguard the Core network chain. It's like having a legion of security experts constantly patrolling, ensuring that everything remains safe and sound.

Token holders also play a crucial role in electing validators. CORE token holders delegate their tokens through a process called staking to cast their votes for who they believe should be responsible for processing transactions and adding new blocks to the blockchain. Bitcoin holders also participate in the election process through a unique Non-Custodial BTC Staking mechanism, allowing them to earn rewards and have a say in the network's governance without giving up control of their Bitcoin.

The elected validators are the choreographers of the network, taking turns to process transactions and create new blocks on the blockchain with meticulous precision. Think of it like a relay race, where each validator seamlessly passes the baton to the next, maintaining a smooth and efficient flow.

This beautiful dance between security and efficiency, fueled by the collaboration of Bitcoin miners, CORE token holders, and validators, with a unique emphasis on the participation of BTC holders through the Non-Custodial BTC Staking, is what makes Core so unique.

## The Validator election

### Rounds, Slots, and Epochs

Imagine the Core blockchain as a bustling city with its internal clock. This clock is divided into "rounds," each lasting roughly 24 hours, although the exact duration can vary slightly depending on network conditions. During each round, the city elects its leaders, known as validators, who are responsible for processing transactions and maintaining the integrity of the blockchain.

Think of it like a relay race, with each validator taking a turn (called a "slot") to add a new block to the chain. A slot is incredibly short, just three seconds each, ensuring a constant flow of activity and swift transaction processing. Every 10 minutes, an "epoch" occurs, acting as a checkpoint to ensure all the validators are doing their jobs correctly and maintaining the network's security and efficiency.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdlYuE2tYcz3dgCWc5ypp9oKeTyZ4kn-VrBwR2EBKH3vKNJYU6wTUGXT1txakyendBG4rY3nqJBSp6lIFaNCPxpVb8JpVAG5D8l5RkjWTECRCLfbvg6z9CkHOzYzpgdF2UoEG20kvvjl_tCn87wrTK0Uj-R?key=RMbE3SnA3hsbj7mtDPGw4Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L6%20P1.gif?raw=true)

### The Hybrid Score

So, how does this city choose its leaders? It's not a high school popularity contest, where the coolest kid wins by default. Instead, it's a carefully balanced process that takes into account both community support and technical contributions. The key to becoming a validator on Core lies in the "hybrid score," a comprehensive evaluation of a validator’s strengths and contributions. Let's break it down.

The hybrid score is like a final grade in school, reflecting a student's performance in multiple subjects. It's a numerical representation of a validator's overall qualifications, taking into account their popularity within the community, their reputation among Bitcoin holders, and the amount of hash power delegated to them. The higher the score, the better the candidate's chances of being elected as a validator.

### The Three Pillars of Validator Success

To be successfully elected as a validator on Core, three factors matter:

**1**. **Staked CORE: The Community's Vote of Confidence**
  - Imagine this as the popular vote. The more CORE tokens (Core's native currency) that are staked, or locked up, with a validator, the higher their score. It's like citizens casting their ballots for the candidate they believe in, showing their trust and confidence in their leadership. The more votes a candidate gets, the more popular they are, and the better their chances of winning.
  
**2**. **Staked Bitcoin: The Cross-Chain Seal of Approval**
  - Bitcoin holders from outside the Core community can also show their support by staking their BTC with a validator through the Non-Custodial BTC Staking mechanism. This means they can participate in Core's governance and earn rewards without giving up control of their Bitcoin. This cross-chain endorsement, secured through innovative technology, acts like a seal of approval from neighboring cities, recognizing the validator's capabilities and potential. It's like getting a glowing recommendation from a respected figure outside your own community.
  
**3**. **Hash Power Delegation: A Measure of Security Contribution**
  - Bitcoin miners, the backbone of Bitcoin's security, also play a crucial role. They can flex their computing power (hash power) by delegating it to a specific validator on the Core blockchain. This act is like a security firm lending its resources to protect the city. In return for their support, miners receive CORE tokens as a reward—a sweet deal for everyone involved! It's important to note that this delegated hash power doesn't just show a validator's technical capabilities but is a direct contribution to the security of the entire Core blockchain.

### The Winning Formula: A Delicate Balance

The hybrid score isn't just a simple popularity vote; it's a carefully crafted formula that balances all three factors:

Hybrid Score = (rHp / tHp) * m + ((rSp + rBp * n) / (tSp + tBp * n)) * (1 - m)

![https://lh7-us.googleusercontent.com/docsz/AD_4nXc8N_ixDcOhelhGn0cSiWUoGT7KYj5DgSI8wkvHNWBcfVahHutafLVsA85EIK3s63M-0KqyvRmbvye7E-uL43Jr3w2xsiifE39wNtbcaIJIfFrD-wsFYagCLcfbKi21ryXu2xKy7PanP-9zy2qCIDcMnQpy?key=RMbE3SnA3hsbj7mtDPGw4Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L6%20P2.gif?raw=true)

Okay, we know this looks like a bunch of gibberish, but bear with us! Here's the breakdown:

- **The Hash Power Factor:** (rHp / tHp) * m
    - This part of the equation is like a pie chart representing the total hash power dedicated to Core blockchain.
    - rHp is the slice of that pie a validator receives – the more hash power they get from Bitcoin miners, the bigger their slice.
    - 'm' is a weighting factor that adjusts how important this "hash power slice" is in the final score. Think of it like a volume knob that can be turned up or down to fine-tune the balance between popularity and security contribution.
- **The Staked Tokens Factor:** ((rSp + rBp * n) / (tSp + tBp * n)) * (1 - m)
    - This is another pie chart, this time representing the total staked tokens (CORE and Bitcoin).
    - The validator's slice grows as more tokens are staked with them, showing the level of trust and investment they've earned from the community.
    - 'n' is a weighting factor that determines how much each staked Bitcoin counts compared to each staked CORE token, like adjusting the value of different currencies.
    - '(1-m)' is the counterbalance to the hash power factor, ensuring that staked tokens have a fair say in the election.

This formula ensures that the hybrid score is a fair and balanced representation of a validator's overall qualifications, taking into account both community support and contributions to network security. It's like a well-rounded assessment of a candidate's leadership potential, considering their popularity, experience, and skills. At the end of each round, the 23 candidates with the highest hybrid scores are elected as validators. They are the backbone of the Core network, responsible for its smooth and efficient operation.

### The Validator Duty

Being a validator is a rewarding job, but it comes with responsibilities. Validators are incentivized to do their job well through block rewards and transaction fees. However, they also face consequences if they don't. If a validator misbehaves or fails to uphold their duties, they can be "slashed" meaning they lose a portion of their rewards or even their initial stake. In more severe cases, they can be temporarily "jailed" (removed from the network) or even permanently banned for stuff like double-signing (maliciously validating two conflicting blocks).

![https://lh7-us.googleusercontent.com/docsz/AD_4nXe2G5XLD_dg-u4JLiw2HKgksY-ege-H9G4ASwXQ04LIVNYQEuq54XlXmq_n0zsxiEYK8moMC6UFzb8YQdGknHjNC-5MckA_y7_Ekyz57j3eleqjQx4efCFKVsuqhx5YEXkqFdAr6J0eoMxKw8dAswMhKMNW?key=RMbE3SnA3hsbj7mtDPGw4Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L6%20P3.gif?raw=true)

**Block Production: Building the Chain**

Once elected, validators take turns adding new blocks to the blockchain. They collect transactions, verify their validity, and package them into blocks, which are then added to the ever-growing chain. This process is essential for maintaining the network's security, ensuring that all transactions are legitimate and irreversible.

### The Core Advantage: A Resilient and Dynamic Network

By combining community support and technical expertise through its unique hybrid scoring system, Core ensures that its leaders are not only popular but also capable of maintaining a secure and efficient blockchain. This decentralized approach, coupled with a system of rewards and penalties, makes Core a resilient and dynamic platform.

## Rewards

In any successful community, there needs to be an incentive to contribute. In Core blockchain, a well-designed reward system is the reason that keeps everyone motivated. By rewarding validators, delegators, and even those who help maintain the network infrastructure.

Core validators get rewarded for keeping the network safe and running by processing transactions and building new blocks. Validators earn rewards in three main categories:

- **Block rewards:** These are freshly minted CORE tokens distributed with each new block created.
- **Transaction fees:** A portion of the fees collected from the block created by the validators. This incentivizes them to prioritize processing transactions efficiently to maximize their fee income.
- **Staking rewards:** Validators share a portion of their block rewards and transaction fees with the users who delegated their CORE/BTC/Hash Power to them. This creates a win-win situation: delegators earn passive income for supporting the network, and validators are motivated to perform well to attract more delegators.

Validators get 90% of base rewards that are distributed after each round, with 10% going to a System Reward Contract. Validators can keep a commission before sharing the remaining 90% with their delegators (CORE stakers, BTC stakers, PoW delegators). The more validators share, the more attractive they become to attract delegators and boost their earnings.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXedgm6bBy3MiS3C-S9CyoR64OL_5nU9jOpu4cJ9eQKBopsIx-S67gkEgSjKVEYk5J_t5sTeRhkoiqFoK928cKDu_KKP0yzqiaRaKuMJowhe7qOPzpfIC5pot7opgmIf-Ga9JKhIZxnt3kyeMfnszFB9TqI0?key=RMbE3SnA3hsbj7mtDPGw4Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L6%20P4.png?raw=true)

### How Rewards are Calculated and Distributed

A somewhat complex mathematical formula determines the exact split,

![https://lh7-us.googleusercontent.com/docsz/AD_4nXeJYN7rrTbBJvqpbZB62rdjT0_HLKTowp2C42NolBSK3VvaRahrW6Og4hepnZGSZF-toVfcy8HhDraj8QNGJwWOoO-bFUr1nW7o2w13FjtKyF0Ca0rG8LZxy9bEHRVZ5u0O_9P5oCn-O21W4z66qaOiAsXI?key=RMbE3SnA3hsbj7mtDPGw4Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L6%20P5.png?raw=true)

In summary, we can say that it depends on two key factors:

- **Block production rate:** This refers to the speed at which new blocks are added to the chain. The faster the blocks are added, the more rewards get distributed, but also get diluted among more validators.
- **Total staked amount:** The more CORE/BTC staked across the network, the more "spread out" the rewards become. Imagine a fixed pool of rewards being divided among a larger group.

### Relayer and Verifier Rewards

Earlier, we mentioned that base rewards are calculated and distributed when the last block of a round is mined, with 90% going to the validators and 10% to the System Rewards Contract. The System Reward Contract is set up to accumulate rewards for relayers and verifiers.

Remember how we discussed in the previous lessons that Bitcoin miners delegate to validators by writing some information into the headers of Bitcoin blocks? Well, **Relayers** are responsible for sending those block headers to Core blockchain. For this cross-chain communications work, they are given a portion of the base system rewards and transaction fees. Relayer rewards are distributed in batches, every 100 Bitcoin blocks.

The **Verifiers** in turn act as vigilant watchmen who constantly monitor validator behavior. If they detect malicious activity like double-signing, they report it. Upon successful verification, the System Rewards Contract immediately rewards them in the same transaction.

The current maximum caps of rewards held by the System Reward Contract are 10 million CORE and 1 million CORE for relayers and verifiers, respectively. Any excess CORE rewards are burnt.

## Security

Even though Blockchain technology offers a secure and decentralized way to manage data and transactions, it's not immune to malicious actors who might try to disrupt or manipulate the system. Core employs a multi-layered security approach to handle these threats.

There are two main categories of attacks that blockchain projects need to be vigilant against:

- **Network Attacks:** These attacks target individual nodes or users to steal funds, disrupt transaction processing, or spread misinformation. For example,
    - Double Spending Attacks: An attempt to spend the same cryptocurrency more than once.
    - 51% Attacks: A situation where a single entity or group controls more than 50% of the network's computing power, allowing them to manipulate the blockchain.
    - Sybil Attacks: An attack where a single entity creates multiple fake identities to gain control or influence over a network.
    - Long-Range Attacks: An attack where a malicious actor tries to replace a significant portion of the blockchain's history with a fraudulent version.
- **Governance Attacks:** These attacks specifically target the decision-making process of the blockchain. Attackers exploit vulnerabilities in the voting or proposal system to gain control or push through changes that benefit them, not the network's health. (e.g., Bribery, Exploiting Voting Mechanisms)

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfI0yqCO34tZXyJIJNe0UDvQEEYYIzko7TD0wPN749neeaT8MfIv2kuhNB3X0g2z5r3Cc7XgUUYGIXMV_RtSmxDNn4i67TDsQXgIgTKP8eg1sy1_5PDstLbj24KlDbBrn7WLLVmzqkhy3dVRm3uOvRCyj-v?key=RMbE3SnA3hsbj7mtDPGw4Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L6%20P7.png?raw=true)

### The Multi-Layered Security Approach

Core safeguards the network through a combination of techniques:

- **Geographic Dispersion:** By spreading validator nodes across various locations, it becomes much harder for attackers to compromise a majority of the network, thus significantly reducing the risk of 51% attacks.
- **Hybrid Consensus Mechanism:** Core's blend of DPoW (Delegated Proof of Work), DPoS (Delegated Proof of Stake), Non-Custodial BTC Staking, and meticulous validator selection bolsters security on multiple fronts. For example, the round-robin block mining process eliminates the risk of "selfish mining" attacks. The requirement for staked CORE tokens and Non-Custodial BTC Staking to participate in validator elections helps to ensure that validators have a vested interest in the network's success and are less likely to engage in malicious behavior.
- **Security Through Incentivization:** The Satoshi Plus system creates a harmonious incentive structure. Miners and stakers, using both CORE and Bitcoin, are rewarded with CORE tokens. This aligns everyone's interests with the network's long-term health and security, discouraging malicious behavior that could harm the network.

## Wrap Up

And there you have it – a behind-the-scenes look at Core's validator selection process. It's a balancing act of community trust, external validation, and technical prowess, all meticulously calculated through the hybrid score formula. This ingenious system ensures that only the most deserving candidates rise to the top, maintaining the network's integrity and security. So next time you hear about Core's validators, remember, that it's not just a popularity contest; it's a carefully orchestrated symphony of trust, technology, and collaboration.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/2.%20Understanding%20Core%E2%80%99s%20Architecture/Lesson%206%20-%20Core%20Workflow.md

Core Workflow

# Infrastructure of Core Blockchain

The world of Decentralized Finance (DeFi) offers exciting possibilities, but navigating it can get tricky. Core simplifies your journey with innovative tools. In this lesson, we will learn about some pioneering DeFi Solutions for Bitcoin offered by Core. We'll be exploring the new stCORE token for liquid staking, coreBTC which is a wrapped version of Bitcoin native to Core, and the Core Bridge that connects Core to other blockchains. We'll also delve into the Core Scan, Core’s block explorer, for transaction analysis and the Core Scan API for programmatic access.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcRiNs0x5K2N6G7NW3ewLLqUKWsYvC2adfvDmMz2ScLWIEru4lZFjqYMh3F1IYOsOVeql3wTSeZ1hFSSg4VsRkaNL53qZTnmoqFpNL08a0xIVmHnbJRnE7xM53ZzwGECW9Y_IDCY1W6AmNKRxrnBS2asTNQ?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P1.gif?raw=true)

But wait, there’s more! The Core team is on a mission to bring billions of people into the web3 world. To make crypto super accessible for everyone, they’ve crafted the [Element wallet](https://www.elementwallet.com/), a game-changer that's both an on-chain messenger and a peer-to-peer payments app. Sounds exciting, right?

Also, the Core team partnered with the Satoshi App to bring you free $CORE airdrops and make you an early adopter of the Core blockchain.

Don’t worry, we’re going to explore all the juicy details in just a bit. Stay tuned!

## Types of Nodes

Before we dive into the nitty-gritty of Core's infrastructure, let's get a good handle on the backbone of the whole system: the nodes. These aren't your everyday computers – they're specialized workhorses running software that keeps the Core blockchain humming. They're like the unsung heroes, working together to ensure everything runs smoothly, securely, and truthfully. Understanding these different types of nodes is like getting a backstage pass to the inner workings of Core.

So, let's lift the curtain and take a closer look at the main players that make up the Core ecosystem:

- **Full Nodes:** These are the backbone of the Core network, maintaining a complete copy of the blockchain. They validate transactions, ensure the integrity of the blockchain, and relay information across the network. There are two types of full nodes:
    - **Normal Full Node:** This node downloads and verifies all blocks and transactions, ensuring the accuracy and validity of the blockchain data. However, it doesn't provide any additional services beyond that.
    - **RPC Full Node:** In addition to the functions of a normal full node, an RPC (Remote Procedure Call) full node provides an interface for external applications (like wallets or explorers) to interact with the blockchain. It allows users to query data, send transactions, and access other blockchain functionalities.
- **Validator Nodes:** These are special nodes that are elected to participate in the Satoshi Plus consensus mechanism. Their primary role is to validate transactions, create new blocks, and maintain the network's security and integrity. To become a validator, nodes must stake a significant amount of CORE tokens and meet certain technical requirements. Validators are incentivized to act honestly through block rewards and transaction fees.
- **Archive Nodes:** Archive nodes are similar to full nodes, but they store the entire history of the blockchain's state, including all past transactions and smart contract data. This makes them invaluable for applications that require access to historical data, such as block explorers or analytics tools.
- **Snapshot Nodes:** Snapshot nodes store the current state of the blockchain, but not the entire history. They are designed to be more lightweight than full nodes or archive nodes, making them easier to set up and run. Snapshot nodes are ideal for users who need to interact with the blockchain but don't require access to historical data.

## stCORE

Staking CORE or stCORE tokens is a LST( Liquid Staking Token ), designed to enhance the utility of CORE tokens and streamline the staking process. While traditional staking contributes to network security, it often restricts token liquidity, hindering users' ability to participate in various DeFi protocols.

stCORE addresses this limitation by creating a liquid staking derivative. By minting stCORE, users can effectively lock their CORE tokens for staking purposes while simultaneously receiving a representation of their staked assets. This representation, stCORE, functions as a tradable token within the DeFi ecosystem, enabling users to leverage their staked CORE for additional opportunities without sacrificing staking rewards.

It’s quite easy to get started with liquid staking with stCORE. You can head out to the [Core Liquid Staking Platform](https://stake.coredao.org/stcore), connect your wallet and then either mint stCORE using CORE tokens or redeem CORE using stCORE. It’s as easy as that.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXftwRqhElSnY5EGcDxbFPYzPmEnimR-hYN71kOMIRv-wRrhvRXIDS1qTd0t1l9l8ZuhSy3yRES_0mW91fJp4iPvgJnN69SreKMGE-ZjjT5JfA7q110VqjHoAPU4j9_lgn9o7XVZFTRJdcr1OHiK0YyZJSo?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P2.png?raw=true)

## coreBTC

coreBTC unlocks the power of DeFi for your Bitcoin (BTC) holdings. Unlike traditional Bitcoin, coreBTC is a **native wrapped BTC** on Core, meaning it maintains a 1:1 exchange rate with BTC. This secure and trustless mechanism, powered by a decentralized network, allows you to seamlessly integrate your Bitcoin into the exciting world of DeFi.

**Benefits of coreBTC:**

- **Effortless DeFi access:** Use coreBTC to participate in DeFi applications on Core blockchain, unlocking opportunities previously unavailable to Bitcoin holders.
- **1:1 BTC peg:** coreBTC maintains a stable 1:1 value with your underlying Bitcoin, ensuring a secure and transparent representation.
- **Decentralized and permissionless:** No central authority controls coreBTC, fostering a secure and trustless environment.

You can head out to the [coreBTC Website](https://bridge.coredao.org/coreBTC), connect your Unisat Wallet, and then either convert Bitcoin (BTC) to coreBTC or vice-versa easily.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdJaI5o46K885jq5IPHwldDNrqB1VfawD8SYCg6PMt8e_3Ro7lBQRrssgtPv7KQNn9qyDTdltBfzDkiVdAc0L7QtfCNIYWvxf5GJrZcFSUltBwGF8ZfxOIIKg72x4FZh7dAOrxrcqqSHtnw9OxV2-iPblXg?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P3.png?raw=true)

## Core Bridge

[Core bridge](https://bridge.coredao.org/bridge) facilitates bi-directional transfer of prominent tokens between Core and other blockchains like Ethereum, BNB Chain, Avalanche, Polygon, Arbitrum, and Optimism.

Benefits of the Core Bridge:

- **Seamless Multi-Chain Connectivity:** Effortlessly move your assets between Core and blockchains like Ethereum, BNB Chain, Avalanche, Polygon, Arbitrum, and Optimism. This flexibility empowers you to explore DeFi opportunities across various ecosystems.
- **Enhanced Asset Management:** The Core Bridge simplifies asset management within the multi-chain landscape. You can effortlessly transfer your tokens, streamlining your DeFi experience without disruptions.
- **Powered by LayerZero Protocol:** The Core Bridge leverages the advanced security and efficiency of the LayerZero Protocol. This ensures fast and secure transactions across different blockchains, adhering to a unified standard.

Imagine having unrestricted access to the vast potential of DeFi, regardless of the underlying blockchain. The Core Bridge makes this vision a reality. You can head onto [Core Bridge](https://bridge.coredao.org/bridge) and then just select the network you want to transfer tokens from to Core or vice versa.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcCKvvaBAfRbzQQ1xqF-D6Z_-Nzsh1qwSf1_POUtQpCJ7tKtTR1SK_TbD7J1e2zOYAdqImllLEVtjojvaAr4L9zl_nqe2yotZ1-RAxYbz17eUv5uEAOPqP_Kbk2FXshDSdJe5Jvz50qytruysXAssJ0ij0?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P4.gif?raw=true)

## Core Scan

[Core Scan](http://scan.coredao.org/) empowers you to search transactions, verify confirmations (how many times a transaction is validated), and even analyze validator performance – all to ensure the smooth operation of the network.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfXyM6gYl5IaDbAUzSK4tcC9-1sdRBBnzecFBECseSmSbS9E0gcMqLLgEMQge_yYW6koTw5eKGbT_ORXkl7ZT7_lIPHAiFEMx7lUbb_44Aw9oQxRIifqdxVjR9B3FkM7PmNGKuuWhWZ3xbzD-qZrLDTW9k?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P5.gif?raw=true)

Following are some of its features :

- **Surgical Transaction Search:** Effortlessly locate specific transactions by hash, block number, or wallet address. No more sifting through endless data!
- **Confirmation Checkup:** Ensure your transactions are secure by verifying the number of confirmations. More confirmations mean a higher level of security.
- **Block Deep Dives:** Go beyond the surface and analyze individual blocks. Explore details like block hash, timestamps, validator information, and included transactions.
- **Validator Watchdog:** Monitor the performance of individual validators. Track metrics like block production rate, uptime, and self-delegation to identify reliable validators.
- **Network Pulse Check:** Gain a real-time understanding of Core blockhain's health. See live data on total transactions, active validators, circulating supply, and other essential network metrics.

## Core scan API

The Core Scan Open API empowers developers to seamlessly integrate Core blockchain data and functionalities into their applications. This community-driven initiative unlocks a wealth of possibilities for building innovative solutions within the Core ecosystem.

To get started,

- Head over to the [Account Registration](https://scan.coredao.org/register) page
- Provide username, email, and password for your account and create your account.
- Verify your account using the confirmation link sent to your email.
- Now you can create your API key for interacting with either the Mainnet or Testnet.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXddATT7ZCe5f6PfvydRGyC7YiCHyhcq2imNjap9GxZpHLZvX22T6HVi306Rmx3F-OfoTOAxGUSK3Lwta96WEIJc2spDxyIytLWi2htcSDIZwXUObyQXL0OzbWsnl-1ryas-aq7_lcjRD9JoOgqmasIl6tXV?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P6.gif?raw=true)

All endpoints and parameter formatting are the same on Mainnet and Testnet, you are only required to change the relevant API endpoint URL as follows.

| Network | Endpoint URL | Documentation |
| --- | --- | --- |
| Mainnet | https://openapi.coredao.org/api | https://docs.coredao.org/api |
| Testnet | https://api.test.btcs.network/api | https://docs.coredao.org/api |

Now we can easily fetch Information about deployed smart contracts, Users' CORE balances and Detailed transaction information using our endpoints.

## Core - Native Wallet & Messenger (Element)

[Element](https://www.elementwallet.com/) is your ticket to a simple, safe, and fun Web3 mobile interface, specially designed for the Core blockchain network. Element makes your Web3 experience a breeze by incorporating easy-to-use touchpoints and ditching those complicated old interfaces.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXeS_6M9x-osA9A-99wb3-N5O3zsqXkaOz5f8ZUf7lAHeBLitSCUriAeiuxDgtNvUDnDMJ5jqQ1c_X9fVpjTEXVhZBMmvmWGuaj8b2MvwJj6Tt09-Z2gH1Ph3I2qOPWdfKD6uE2W8ffHss81duhJk9cTQFI?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P8.png?raw=true)

Teaming up with Core, Element lets you seamlessly navigate and interact with the Core blockchain. Launching in 2023 on iOS and Android, Element isn't just an app—it's set to become the ultimate platform for your digital life.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdoNTWObGNCUe6Ux5AgXO1ln2UtA1oKR5YEmvRegcHm5kv0C3iW2LqlFr52JD-6jUvmtX9c6VwG8v5U0pLJ-U0U7exE7DL961tDsAq24BT8Eq9hmTE0FlH0k6GEoMRvAguwPB1DDZtDtWLu9rbXMrqUMQ4f?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P9.png?raw=true)

Element is also a game-changer in messaging! With rock-solid end-to-end encryption and blockchain magic, your chats are private and unalterable. Unlike cloud-based apps, Element puts you in control. Forget the fuss with WhatsApp or Telegram; Element is all about privacy from the start.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcFjPW9cyhGXMvDBad6OBVGHPRBv0eCI4jAG8vm0pc9sEhmk1UFLyz7f67LXVyBq0HS53UAr6yEMO1Y9tHwLakPvyhL6he3UuuNRgJXnm_vsp-8cLWC6s500Eu8lRABNtml1j0jli3CfuYoSzldiB9ETeQY?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P10.png?raw=true)

## Satoshi App

![https://lh7-us.googleusercontent.com/docsz/AD_4nXexlcrShHia22TMLm6XifHObhlnnX5FxQC_EsBjQS01g3VHfnobbhZosk7UUt-hNgimqYJEoJrzcWET82ayh-mo9_sGokKKJBOv3moX8enh_FlObiiU9UDyTNIA7ZPvYTjY2Wbggd597S9ZMu_BrUwP7R0?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P11.png?raw=true)

Satoshi was a trailblazer, that introduced the Core blockchain to over 11 million users, driven by thorough research and unwavering belief in its potential. The Satoshi app not only airdrops CORE tokens but also allows you (the users) to mine the CORE tokens using the mobile application.

In April 2024, CORE, the inaugural project on the Satoshi APP, skyrocketed with an unbelievable 400+% surge in its price, pushing its market cap past a jaw-dropping $3.2+ billion! This incredible leap isn't just a victory for CORE fans; it's a shining symbol of Satoshi App's core values. Here’s the chart image from the CoinMarketCap.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfqMPOQwimOmmvYldJwTjOtV3GmPHx1hIWlA7VoCNs6RKQW9TfnnQQwXHPOJxH7GbfVbOQyBogg7pntGYA0Z3mhhcnIRsdB0DRV4ut5uvHFP24-D2tI3Qn4kMa_cIe1h0uM-LZroF1P-0Q2Eloafqmg9B4?key=95ak5YnMLrnhV2lMqJWnXw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L7%20P12.png?raw=true)

This epic tale of success isn't just for Satoshi to celebrate—it's shared with over 2 million users who placed their trust in CORE and joined them on this thrilling journey.

## Wrap Up

From staking and wrapped assets to seamless transfers and network insights, Core equips you with multiple tools to fully utilize what Core blockchain has to offer.

Next up, we will explore different platforms where you can stake your CORE tokens and not only this, we will explore some additional resources that will help you get on board with the Core blockchain with ease.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/2.%20Understanding%20Core%E2%80%99s%20Architecture/Lesson%207%20-%20Infrastructure%20of%20Core%20Blockchain.md

Infrastructure of Core Blockchain

# Core Ecosystem and Future Roadmap

Phew, we've covered a ton about Core already, haven't we? From its roots and that cool Satoshi Plus consensus to its inner workings and smooth operations, you've become quite the Core expert!

But buckle up, because the fun is just getting started! Core isn't just about the tech – it's a buzzing ecosystem bursting with awesome dApps that are changing the game.

Ready to see what the hype is all about? Let's dive into why people are loving Core and peek at some of the amazing stuff the community is cooking up. We're talking games, DeFi, launchpads, developer tools, wallets – the whole shebang! Let’s just dive in and explore what the core ecosystem is all about.

## A Thriving Ecosystem of Builders and Users

So, to make Core the go-to place for amazing decentralized apps (dApps), it needs to be awesome for both the people who make them and the people who use them, right?

And guess what? Core's got it all! For the techy folks building the apps, Core offers a combination of scalability, security, and developer-friendly tools. Its innovative consensus mechanism ensures fast and secure transactions, while its compatibility with EVM simplifies the development process. Lower gas fees and a growing community further enhance Core's appeal, making it a prime platform for building the next generation of decentralized applications.

Additionally, Core supports Non-Custodial BTC Staking, which allows users to earn rewards by staking their Bitcoin directly from their own wallets, maintaining full control over their assets while contributing to the security and decentralization of the network.

It's not just the developers who are in for a treat, though! Core also delivers a seamless user experience with lightning-fast transactions, minimal fees, and top-notch security. Plus, the Core community is super passionate and always pushing the boundaries of what's possible. So whether you're a builder or a user, Core's got you covered. It's a win-win situation, and that's what makes this ecosystem so exciting!

We all know that an ecosystem is thriving when currently, according to https://coredao.org/ at the time of writing, there are 2.3M Twitter Followers, 258M+ Transactions On-Chain, 267K Discord Members, and 5M Active Wallets. It’s time to explore some awesome dApps this community is creating and using.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXe15qyjEsJbBD0Vh47CRD89M8YXc09SYv6TdLS69zYm6zZ08qsQwKHu1QQttgKLo48Tt0fpuyR80kpAXACFKR4bLrrBtndD1jUEHPJGQZt8kmNqcNOWOoMYxIa0FXJ5CnZv8iL8_EY7xUoyn4i5nk09rhCL?key=k4kZrmvdR6k9od8EuSjt4g](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L8%20P1.png?raw=true)

## Exploration of notable decentralized applications (dApps) built on Core

The dApps on Core covers a wide range of use cases from Defi, Gaming, NFT, Launchpads, Bridges, Dev Tools, Exchanges, Wallets, etc. Let’s start by exploring some amazing decentralized apps (dApps).

### Dev Tools

![https://lh7-us.googleusercontent.com/docsz/AD_4nXeBbNaln5Vm-KnNYGtlPCv3uJDXzG7pSVB2mhftiT9s_eGipORJTNBIYrSJLmFHCUoUvSvKG7D-2KBomS-nudrHnpPWyjA3JA8jZF9GMcPDUA6zfvw5ZRjQWqYmG47gW3P-g58WdOM21GUBLnTejX8USWeH?key=k4kZrmvdR6k9od8EuSjt4g](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L8%20P2.png?raw=true)

Core's got some seriously cool developer tools to make building on the blockchain a breeze. For example, projects like Footprint Analytics let us easily visualize and understand blockchain data, while Supra and Switchboard provide powerful Oracle solutions for our dApps. Bonsai3 is an all-in-one Web3 hub, and TaskOn makes collaboration a breeze. And for all game developers, Altura is here to supercharge Web3 gaming experiences. With so many incredible tools at your fingertips, who wouldn't want to build the next big thing on Core?

### Defi (Decentralized Finance)

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfJCbQOZDPqZHdvtqvUjdX1e-IqMOf6rWSUEuAVZfhPxjO6bwMnqqgsDwcROFi8I_eMnVEzRDjjHmDXLFmLGi7xv4orm58q_t1kBjHw3wtbtl1yEbdb2c9Rh2xwpuf2kgxCesqNn9veERenA6uAGWug2Yo?key=k4kZrmvdR6k9od8EuSjt4g](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L8%20P3.png?raw=true)

Speaking of DeFi, Core has a growing list of decentralized finance platforms that are perfect for both seasoned investors and newbies alike. We can easily swap tokens, earn yield, or explore the possibilities of decentralized finance on platforms like Akka, Bit Stable, Archer Swap, Colend, Glyph Exchange, Ice Cream Swap, Omni BTC, and PinkSale. Core makes it easy and secure to dive into the future of finance!

### Wallets

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdpc2MmEt1NKtqYzkGyIEdyMY1q0HlMSjcH6PlKAhGnQWUsk6aRNd0o1K3CSNwFP2VsFp4JHnrPl6BLCk9TUNpnDVaizsLSpWppuGiJJ6iRfjcIfei1pLd8SUYSF3nBeG17IxuN9iZcfMAvfQa-e7iiNGJP?key=k4kZrmvdR6k9od8EuSjt4g](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L8%20P4.png?raw=true)

As users, we can see that it is easy to manage our Core assets using popular and trusted options like MetaMask, Atomic Wallet, Bitget Wallet, FoxWallet, Math Wallet, etc. These wallets offer a secure and convenient way to store, send, and receive CORE tokens, plus many integrate with the broader Core ecosystem, allowing us to interact with dApps and other blockchain features effortlessly.

### Exchanges

![https://lh7-us.googleusercontent.com/docsz/AD_4nXe57QznbIpuN-sqfAwe8PVd1PmgkDsJ-Gme4esy9VQ_BDW4Pg6Fbqjd3_0pPZ26N0UCzQ4ikp8BaBGE2OqAD_8S8qhO7HzqpSZmW2YDyUDzRz19ykm_vUCLYqMCl2TZWOQeBazV_13ZIMicUGnlnEwRxlG9?key=k4kZrmvdR6k9od8EuSjt4g](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L8%20P5.png?raw=true)

Core's got a whole bunch of exchanges where we can swap our tokens around. We've got options like ArcherSwap, Bitget, ByBit, Eddy Finance, Gate, Glyph Exchange, Huobi, and MexC. It's super easy to swap CORE tokens for other cryptocurrencies or even cash out. It's like a crypto playground, but way more grown-up!

### Launchpads

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdTBtDK8LopeQQPOw4pt2RrPYMnnZcGYaaUwhrG-2KVeJCaOup9UaKouCYA6ULHuqaPkfnVyzMeOYMfzGJ-UhaehaoZ0N4dWvaZ5BMewzxgZFv2Yi9nxs2GwwCNhm-s4lvWGjYExXSOlZg6fulkE3IHipkU?key=k4kZrmvdR6k9od8EuSjt4g](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-core-c1/Section%202%20Images/L8%20P6.png?raw=true)

Core partners with platforms like Decubate, Elixir Games, Miidas, and Ordify, where we can discover the most promising new dApps and tokens before anyone else. They're all about supporting new ideas and giving us early access to invest in the future of Web3. So, who knows, maybe you'll be the first to discover the next unicorn dApp – made possible through Core's awesome partnerships!

But that's not all, folks! The Core ecosystem is just getting started. We're likely to see even more innovative dApps popping up, pushing the boundaries of what's possible in areas like NFTs, the metaverse, and decentralized social media. With Core's ongoing commitment to technological advancement, we can expect even faster transactions, lower fees, and more robust security in the future. So, keep an eye on Core – it's a blockchain that's ready to take on the world!

## The Future of Core

Core, though new, is already causing a stir in the crypto world. It's a promising project with big goals: to change how we use digital money. It's unique because it combines security, flexibility, and community involvement. Core isn't just another blockchain, it's a new way of thinking about the future.

And the best part? Core isn't slowing down! There are many exciting changes coming to Core. They want to make Bitcoin even better, all while keeping it secure and in the hands of the people. Let's see what's in store for Core:

- **Local fee Market:** Core has an exciting feature on its roadmap: local fee markets. This innovation aims to provide users with greater control and predictability over transaction fees, enhancing the overall user experience.
- **Atomic Swaps for Seamless Trading**: Core Chain is also looking to integrate trustless atomic swaps – a fancy term for a secure way to exchange cryptocurrencies between different blockchains. This means you could seamlessly trade your assets between Core blockchain, Bitcoin, and other compatible networks, opening up a whole new world of possibilities.
- **Bitcoin on Steroids**: Core is not just about using Bitcoin for security; it's about supercharging it. They're working on enhancements to coreBTC, the Core-native wrapped Bitcoin, to make it even more secure and versatile. And they're exploring the idea of using coreBTC as a gas token, which means you could pay for transaction fees using Bitcoin – how cool is that?
- **Liquid Staking**: Liquid staking on Core empowers CORE/BTC holders to earn Core Consensus rewards while retaining the flexibility to utilize their assets. Core offers two distinct forms of liquid staking to maximize your participation in the ecosystem. You can already enjoy the benefits of liquid staking with your CORE tokens using stCORE, earning rewards while maintaining flexibility for various activities within the ecosystem. While liquid staking for Bitcoin is under development and not yet launched, its upcoming release will enable you to earn rewards on your Bitcoin while still being able to use it within the Core ecosystem.
- **Sharing the Security Love**: Core is so confident in its Bitcoin-backed security that it plans to share it with other projects. This means other blockchains and protocols could benefit from Core's robust security infrastructure, creating a more secure ecosystem for everyone.

This is just a taste of what's to come. Core is a young and ambitious project, and its future is full of exciting possibilities. As it continues to evolve, we can expect even more innovative features and applications that will further solidify its position as a leading player in the blockchain space. So stay tuned, because Core blockchain has just started!

## Wrap Up

Phew! We've covered a lot of ground exploring the Core ecosystem. From why it's awesome for both builders and users to the different types of dApps popping up, it's clear that Core is a blockchain on the rise. But this is just the beginning! Head over to the [Core Ecosystem page](https://coredao.org/explore/ecosystem) to discover even more exciting dApps and stay up-to-date on the latest developments. As more and more developers and users join the community, we can expect even more exciting innovations to emerge. So, keep exploring – the Core journey is only getting started!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/2.%20Understanding%20Core%E2%80%99s%20Architecture/Lesson%208%20-%20Core%20Ecosystem%20and%20Future%20Roadmap.md

Core Ecosystem and Future Roadmap

# Let’s Wrap Up the Course

Alrighty, folks, it's time to break out the confetti and party hats! 🎉 Can you believe it? You've reached the finish line, and let me tell you, it's no small feat. Pat yourselves on the back for sticking with it and rocking this course like pros!

Now, let's take a little trip down memory lane and soak in all the awesome knowledge you've soaked up along the way.

## What we learnt so far

In this course, we got a thorough understanding of the Core blockchain. Let’s see what we covered:

- We dove headfirst into its history and got cozy with the why behind its creation.
- From security focus to its scalability dreams, we explored how Core has been shaped.
- We rolled up our sleeves and got our hands dirty understanding the movers and shakers behind the scenes: validators, miners, stakers, relayers, and verifiers.
- We learnt about the Satoshi Plus consensus mechanism. It's like the coolest blend of Bitcoin’s Proof of Work, Delegated Proof of Stake and Non-Custodial BTC Staking making sure our blockchain stays secure.
- We also got an understanding of the Core network workflow and infrastructure of Core.
- Last but not least, we also got a sneak peek at the many exciting apps being built on Core, from decentralized finance (DeFi) and games to exchanges and wallets.

## ⚒️ A small yet important request

Here is great news for you! 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). If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://bit.ly/core-course-discord) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our [repository](https://github.com/0xmetaschool/Learning-Projects). 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/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn) as well. 🫶
3. Subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos.

Also, now that you have a strong understanding of Core, Why don't you take the next step and become an active participant in the Core ecosystem? Here's how you can get involved and make your mark:

1. Join their [Telegram channel](https://t.me/CoreDAOTelegram), [Discord channel](https://discord.com/invite/coredaoofficial).
2. Follow Core Chain on [X](https://twitter.com/Coredao_Org), [X account for Devs](https://x.com/corechain_devs), and subscribe on the [YouTube](https://www.youtube.com/@Core_DAO_Official) channel.
3. Contribute directly to the CoreDAO [Github Repository](https://github.com/coredao-org).

## 🎊 Congratulations

You have successfully completed this course and now have a good understanding of Core and what makes it stand apart. You are now ready to explore and dive even deeper into the Core ecosystem.

WAGMI! Peace out! ✌🏻🔮



https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20Core/3.%20Wrap%20Up/Lesson%209%20Let%E2%80%99s%20Wrap%20Up%20the%20Course.md

Let’s Wrap Up the Course

This course offers a practical approach to mastering Bitcoin-centric decentralized finance on the Core blockchain. You'll learn to build a fully functional lending dApp while gaining proficiency in Solidity. The course covers Core programs for developers, BTCfi, smart contract creation, frontend integration, and deployment on the Core testnet, providing a hands-on and in-depth understanding of development on the Core blockchain.

# What Are We Building Today?

Hey there, developer! 👋

So, you've been poking around Core blockchain and you're ready for more, huh? Awesome! That means you're in the perfect spot to level up your skills and go from a Core admirer to a full-fledged Core dApp builder! 🚀  First things first, let’s give you a big round of applause for completing the [first course on Core](https://metaschool.so/courses/introduction-to-core). Woohoo! 🎉

Side Note: Btw, following official github repos of blockchains and interacting with it is a great idea. Blockchains airdrop and consistently reward their followers. Do follow Core [here](github.com/coredao-org)

Building on Core isn't just about code; it's about joining a revolution powered by Bitcoin's security and EVM compatibility. You get the best of both worlds: the rock-solid foundation of Bitcoin's decentralization and the flexibility of Ethereum's smart contract development to build BTCfi dApps. It's like having a Swiss Army knife for blockchain development!

And the cherry on top? A thriving ecosystem of dApps is already taking shape! Dive into decentralized finance (DeFi), explore exciting NFT marketplaces, or even create your own gaming universe. With Core, your imagination is the only limit, and this course is designed to equip you with the tools and knowledge to turn your ideas into dApps!

We have already discussed the Satoshi Plus Consensus Mechanism, Non-Custodial BTC Staking, the architecture, the primary goals, the ecosystem and the future roadmap in our first course. This course ensures you pick up practical skills and confidence, starting with building your own Lending dApp. As you progress, you’ll learn new concepts and add more functionalities to your dApp.

## The Lending dApp
This course will equip you with the knowledge and skills to build the **core functionalities** of a lending dApp:

<a href="https://youtu.be/jnPWUEOcI0E" target="_blank">
 <img src="https://github.com/0xmetaschool/Learning-Projects/assets/130544719/5cc96e37-91f1-4090-b165-c51ea9818fc4" alt="Watch the video" />
</a>

But why build a Lending dApp, you ask? Buckle up, because this isn't just about crunching numbers! This seemingly simple app serves as a powerful **launchpad** for your Core blockchain development journey. Here's why:

- **Hands-on Learning:** Building a Lending dApp is an engaging and practical way to grasp blockchain concepts like **smart contracts**, which are self-executing programs that power dApps.
- **Unlocking Bitcoin's Utility:** This project highlights Bitcoin's potential beyond its traditional role as a store of value. By incorporating Bitcoin as collateral in the Lending dApp, you'll witness firsthand how Bitcoin can participate in the growing world of decentralized finance.
- **Solidity Fundamentals:** You'll delve into Solidity, the programming language designed for creating smart contracts on EVM-compatible chains. By building the Lending dApp, you'll gain a strong foundation in Soldity’s syntax and functionality.
- **Deployment and Interaction:** The excitement doesn't stop at coding! You'll deploy your Lending dApp onto the Core blockchain, allowing you to interact with it and see your code come to life in a decentralized environment.

## Course Overview

We will:

1. Learn about the advantages of building on Core
2. Explore various Core community and developer programs
3. Setting up Core development environment
4. Connecting to the Core testnet & acquiring testnet CORE tokens from the faucet
5. Learn how to Build and deploy a Lending app on Core using Solidity

## Who Exactly Should Take This Course?

This course is for beginner and experienced Web3 developers who wish to learn about Core and have completed our first introductory course on the Core blockchain. You should have basic programming knowledge as it will help you have a quick start to this course but if not, we are here for you!

## What Will You Be Getting Out of This Course?

You will be getting the following outcomes when you complete this course:

1. Get a good understanding of the development on Core
2. Get yourself ready for the next advance level course in the series
3. Claim your NFT on course completion

## Proof of completion

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

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L1%20Image%201.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/Jf4ArqVb) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [Github](github.com/0xmetaschool), it would be a great support. 🫣
4. Stay happy and positive!

Alright guys, no need to wait any longer. Let’s get started!!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/1.%20Introduction%20to%20Building%20on%20Core/1.%20What%20are%20we%20building%20today%3F.md

What Are We Building Today?

# The Bitcoin-Centric Advantage

Ahoy, blockchain pioneers! Bitcoin, the OG of cryptocurrency, is often hailed as "digital gold"—a safe haven for your hard-earned wealth. But let's be honest, who wants their treasure just sitting in a vault, gathering dust?

Get ready to ditch the "HODLing" mindset and embark on a thrilling expedition into the future of Bitcoin. We're talking about Core and BTCfi—a dynamic duo that's transforming Bitcoin from a static store of value into a versatile financial powerhouse.

![img-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L2%20Image%201.webp?raw=true)

Picture this: smart contracts, decentralized apps (dApps), lending, borrowing, and trading—all powered by the security and decentralization of Bitcoin. It's like upgrading your treasure chest into a bustling marketplace where your Bitcoin isn't just sitting pretty; it's working hard for you.

## Core: The Bitcoin-Powered Metropolis

Imagine Bitcoin as a colossal medieval fortress, built on solid rock and guarded by a legion of miners. It's a bastion of security and decentralization, but life within its walls can feel a bit... well, medieval.

Now, picture Core as a futuristic metropolis built right on top of that fortress. It inherits the fortress's impenetrable walls and unwavering stability while adding a dazzling array of modern amenities, vibrant markets, and limitless opportunities.

![img2](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L2%20Image%202.webp?raw=true)

Here's the twist: this isn't just any city; it's linked to the fortress. It draws energy from the fortress's defences, and its citizens actively contribute to fortifying the walls.

That's the essence of Core. It's a blockchain that leverages Bitcoin's unparalleled security and decentralization while expanding its capabilities. This integration is a win-win:

- **Fort Knox-Level Security:** Bitcoin's army of miners acts as a vigilant security force, constantly guarding Core from potential threats. This makes it an ideal platform for building and using decentralized applications where trust and security are paramount.
- **The People's Chain:** Just like Bitcoin, Core is decentralized – no single entity or government controls it. This ensures the platform remains open, transparent, and resistant to censorship, allowing for truly permissionless innovation.
- **Empowered Bitcoiners:** Bitcoin holders aren't just passive observers in this metropolis. They can actively participate in securing the network by staking their BTC—essentially locking it up for a certain period. In return, they earn rewards in CORE, the native token of Core. It's like adding another layer of defence to the fortress while earning a handsome salary for your service.

## Satoshi Plus: The Consensus Powerhouse with Non-Custodial BTC Staking

As discussed in the previous course, Core achieves a harmonious blend of Bitcoin's robust security and the innovative capabilities of decentralized finance (DeFi) through its unique consensus mechanism called Satoshi Plus. It's a hybrid system that cleverly combines Bitcoin's Proof of Work (PoW) with Delegated Proof of Stake (DPoS) and Non-Custodial BTC Staking for both security and scalability.

But what truly sets Satoshi Plus apart is its groundbreaking approach to Bitcoin staking. Through Non-Custodial BTC Staking, Bitcoin holders can actively participate in securing the Core network without relinquishing ownership or control of their BTC. This is achieved through a trustless mechanism that utilizes Hashed Timelock Contracts (HTLCs). Bitcoin holders create a special transaction on the Bitcoin blockchain, locking their BTC for a specific period. They then provide proof of this transaction to Core, which allows them to delegate their staked Bitcoin to a validator. This process ensures that the Bitcoin remains on the Bitcoin blockchain while simultaneously enabling the holder to participate in Core’s consensus mechanism and earn CORE rewards.

## BTCfi: Unleashing Bitcoin's Financial Potential

Now that we've established the secure and innovative foundation of Core, let's explore its most exciting application: BTCfi, or Bitcoin Finance.

![img3](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L2%20Image%203.webp?raw=true)

BTCfi is a rapidly growing sector of the decentralized finance (DeFi) movement that focuses on leveraging Bitcoin as a financial asset. It aims to unlock Bitcoin's potential beyond its traditional role as a store of value by enabling a wide range of financial activities directly on the blockchain.

Imagine being able to lend your Bitcoin and earn interest, borrow against it without a traditional bank, or trade it on decentralized exchanges with unparalleled security. These are just a few examples of what BTCfi can offer.

## The Potential of BTCfi on Core

Core aims to unlock the $1Trillion Bitcoin economy and unlock the landscape of DeFi opportunities and utility use cases for Bitcoin. With its seamless Bitcoin integration and robust security, is the ideal platform for BTCfi to flourish. It provides the infrastructure for developers to build innovative BTCfi applications and for users to safely access a wide array of financial services.

The potential of BTCfi is immense. It could:

- **Increase Bitcoin's Utility:** Transform Bitcoin from a passive asset into an active financial tool, opening up new avenues for earning and growth.
- **Expand Financial Inclusion:** Provide access to financial services to those who are underserved by traditional banking systems, democratizing finance globally.
- **Drive Innovation:** Spark the creation of novel financial products and services that were previously impossible, leading to a more diverse and inclusive financial landscape.
- **Enhance Bitcoin's Value Proposition:** By increasing demand for Bitcoin as a productive asset, BTCfi could potentially drive up its price and further solidify its position as the leading cryptocurrency.

## The BTCfi Ecosystem on Core

The BTCfi ecosystem on Core is rapidly expanding, with a growing number of applications and services being developed and deployed. Some of the key areas of BTCfi innovation include:

- **Lending and Borrowing Platforms:** Enabling users to earn interest on their Bitcoin holdings by lending them out or borrowing against their Bitcoin as collateral. This opens up new avenues for passive income and financial flexibility.
- **Decentralized Exchanges (DEXs):** Facilitating the secure and transparent trading of Bitcoin and other cryptocurrencies without intermediaries. DEXs on Core benefit from Bitcoin's security while offering a wide range of trading pairs and opportunities.
- **Yield Farming and Liquidity Mining:** These platforms offer additional rewards to users who provide liquidity to BTCfi protocols, further incentivizing participation and boosting the ecosystem's growth.
- **Bitcoin-Backed Stablecoins:** A major breakthrough in BTCfi is the ability to create stablecoins backed by Bitcoin-native assets (like ORDI, BTC, MUBI, BSSB) and EVM assets (like USDT and FDUSD). **BitStable** is a prime example, incorporating CORE and other Core ecosystem assets. This innovation not only expands the utility of Bitcoin but also provides a stable medium of exchange within the DeFi landscape.
- **Synthetic Assets:** Creating tokenized representations of real-world assets (e.g., stocks, commodities) backed by Bitcoin’s security. This opens up new investment opportunities and brings traditional assets into the DeFi space.
- **Insurance Protocols:** Providing protection against smart contract risks and other potential losses in the DeFi space, adding a layer of security and trust for users.

## Wrap Up

Core and BTCfi are revolutionizing how we perceive and interact with Bitcoin. They are not just building upon Bitcoin's legacy but are actively shaping its future.

The combination of Core’s secure and decentralized infrastructure, Satoshi Plus's innovative consensus mechanism with Non-Custodial BTC Staking, and BTCfi's expanding financial ecosystem has the potential to unlock a new era of possibilities for Bitcoin.

But the excitement doesn't stop here. Core isn't just a platform for building and using financial applications; it's a vibrant ecosystem with a thriving community. In our next lesson, we'll delve deeper into the heart of this ecosystem, exploring the various programs and initiatives that Core has launched to foster innovation, collaboration, and growth.

We'll uncover how you can become an active participant in this revolutionary ecosystem, whether you're a developer, an entrepreneur, or simply an enthusiast eager to contribute to the future of Bitcoin. So, stay tuned for our next adventure into the heart of the Core community!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/1.%20Introduction%20to%20Building%20on%20Core/2.%20The%20Bitcoin-Centric%20Advantage.md

The Bitcoin-Centric Advantage

# Exploring Core Programs

Ahoy again, blockchain crew! Last time, we embarked on a thrilling journey into the world of Core and BTCfi, exploring how this innovative blockchain is unleashing Bitcoin's full potential. We dove into the tech – Satoshi Plus, Non-Custodial BTC Staking, and the burgeoning BTCfi ecosystem. But Core isn't just about code and protocols; it's a thriving community of builders, innovators, and dreamers who are passionate about creating a Bitcoin-powered future.

In this lesson, we're shifting gears from the tech specs to the human side of Core. Get ready to discover the exciting programs and initiatives that are fueling the growth of this ecosystem and empowering individuals like you to become part of the Bitcoin revolution.

## Core Academy: Learn the Basics of Bitcoin and Blockchain

Explore the fundamentals of blockchain technology with [Core Academy's](https://coredao.org/join/core-academy) easy-to-follow blogs and guidebooks. Learn about the building blocks of this revolutionary tech, from the basics of what a blockchain is to the different types that exist. Discover how consensus mechanisms keep the network secure and dive into the world of cryptocurrencies, NFTs, and wallets.

Core Academy will also guide you through essential Web3 concepts like dApps, smart contracts, DAOs, DeFi, and BTCfi. And of course, you'll learn about Core in specific like its fundamentals,  Satoshi Plus consensus mechanism, Non-Custodial BTC Staking etc.

![img1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%201.webp?raw=true)

## Core Ambassador Program: Spreading the Bitcoin Gospel

Passionate about Core and want to share the good news with the world? [The Core Ambassador Program](https://coredaofoundation.org/ambassador-program) is your chance to become a vocal advocate for this revolutionary platform. As an ambassador, you'll:

- **Educate and Inspire:** Share your knowledge of Core with your network and community, helping others understand its benefits and potential.
- **Build Community:** Organize meetups, workshops, and online events to connect with fellow Core enthusiasts.
- **Earn Rewards:** Get recognized and rewarded for your contributions to the growth of the Core community.

The ambassador program is open to anyone with a passion for Blockchain and a desire to make a difference. It's a fantastic opportunity to learn, connect, and make a real impact in the blockchain space.

![img2](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%202.webp?raw=true)

## Core Starter Program: Launching Your BTCfi Venture

[The Core Starter Program](https://coredao.org/initiatives/corestarterprogram) is a comprehensive initiative designed to accelerate the development of decentralized applications (dApps) on the Core blockchain. Combining the security of Bitcoin with the versatility of the Ethereum Virtual Machine (EVM), Core offers an ideal platform for building the next generation of Web3 solutions, particularly in the emerging field of Bitcoin Finance (BTCfi).

This program offers an array of benefits to empower developers and projects:

- **Security:**
    - Discounted rates on security audits from [Hacken](https://hacken.io/) (20% off) and [Halborn](https://www.halborn.com/) (5% off).
- **Financial Services:**
    - Two months of free financial process management with [Request Finance](https://www.request.finance/).
- **Cloud Services:**
    - Fast-tracked application review, combined [Google Cloud](https://cloud.google.com/) and Firebase credits of up to $200,000 over two years, additional support credits, and complimentary Google Workspace Business Plus upon enrollment.
- **Other Benefits:**
    - Free hosting for Core games on [Elixir](https://www.elixir.app/) for one year.
    - 20% off security audits from [ExVul](https://exvul.com/) for projects launching on Core.
    - Two weeks of free development on [Questly](https://www.questly.quest/) for Core developers.
    - [TokenSoft](https://www.tokensoft.io/): Receive a 10% reduction on compliance checks, save \$5,000 on token foundation entity setup, and get $10,000 off TokenSoft Awareness for a year.

The Core Starter Program invites builders to join a vibrant and supportive community while leveraging a powerful platform for innovation.

You can claim your Core Starter program offers by filling out [this form](https://forms.gle/MTYRVCKecZmYs1qS8).

Build the future of Web3 with Core!

![img3](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%203.webp?raw=true)

## Core Chain Ventures: Investing in the Bitcoin-Powered Future

[Core Chain Ventures](https://corechain.ventures/) is the investment arm of the Core ecosystem. It's on a mission to identify and support the most promising projects building on the Core platform. This includes a wide range of initiatives, from decentralized finance (DeFi) protocols and non-fungible token (NFT) marketplaces to essential infrastructure projects that underpin the entire ecosystem.

Core Chain Ventures isn't just about throwing money at projects; it's about strategic partnerships that fuel growth and innovation. By investing in a diverse portfolio, Core Chain Ventures aims to:

- **Accelerate Growth:** Provide the necessary capital and resources for projects to scale and reach their full potential. This could involve funding marketing campaigns, expanding development teams, or establishing key partnerships.
- **Foster Innovation:** Support groundbreaking ideas that are pushing the boundaries of what's possible with Bitcoin and blockchain technology. Core Chain Ventures is particularly interested in projects that tackle real-world problems and create value for the community.
- **Strengthen the Ecosystem:** Create a thriving ecosystem of interconnected projects that benefit from each other's strengths. By fostering collaboration and cross-pollination, Core Chain Ventures aims to build a robust and sustainable ecosystem that can withstand the test of time.

Whether you're a project seeking funding or an investor looking for opportunities in the BTCfi space, Core Chain Ventures plays a crucial role in driving the growth and development of the ecosystem.

![img4](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%204.webp?raw=true)

## Core Chain Wishlist: Your Voice, Your Vision

[The Core Chain Wishlist](https://github.com/coredao-org/core-community-contributions/blob/main/Core-Wishlist.md) is a unique platform where community members can submit their ideas and suggestions for improving the Core platform. It's a testament to the Core’s commitment to community-driven development.

Your ideas could shape the future of Core. Whether it's a new feature, a dApp idea, or a suggestion for improving the user experience, your voice matters.

![img5](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%205.webp?raw=true)

## Core Foundation Grants: Fueling Community-Led Innovation

Got the next big idea in blockchain? Core Foundation has rolled out its [grants program](https://coredaofoundation.org/fund-your-project) to drive innovation and growth within its ecosystem. This initiative invites developers and visionaries eager to make a mark in the blockchain space, especially within the Core ecosystem. Whether you're an experienced developer or just starting out, if you're passionate about building on the Core blockchain, this is your opportunity to shine.

The grants program offers two types of support:

- **Builder Grants:** Ideal for early-stage projects needing a boost to get off the ground.
- **Growth Grants:** Designed to help existing Core projects scale up and reach new heights.

**What kind of projects are Core looking for?**

Core Foundation is open to a wide range:

- **GameFi:** From casual games to complex prediction markets, they're looking for your blockchain-based innovations.
- **DeFi:** Innovative lending/borrowing protocols, DEXs, and derivatives platforms are highly encouraged.
- **SocialFi:** Got an idea to blend social networking with DeFi? They’re all ears!
- **Infrastructure:** Help build a better Web3 by improving tools and resources for Core dApp developers.
- **The Unexpected:** Have a wild idea? Surprise them with your innovative and experimental dApps.
- Etc..etc…etc….

The Core Foundation Grants program is a testament to the project's commitment to fostering a vibrant and decentralized ecosystem where innovation thrives.

![img6](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%206.webp?raw=true)

## Core Builder Incentive Program: Igniting the Spark of Creativity

[The Core Builder Incentive program](https://coredao.org/explore/blog/core-builder-incentive-program) is a special initiative aimed at attracting and rewarding up to 400K CORE tokens on monthly basis to qualified projects building on the Core blockchain. It offers a range of incentives, including:

- **Financial Rewards:** Monthly rewards for achieving milestones based on 3 performance metrics - TVL, DAU, and Transaction Count.
- **Recognition and Visibility:** Opportunities to showcase your work to Core community and potential users.
- **Networking and Collaboration:** Access to a network of fellow developers and mentors who can provide support and guidance.

The Core Builder Incentive program is designed to spark a wave of creativity and innovation on the Core platform, attracting top talent and fostering a thriving developer community.

![img7](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L3%20Image%207.webp?raw=true)

## Community Check-In

We know that diving into a new blockchain platform can be both exciting and challenging. If you're feeling stuck or have questions as you explore Core blockchain, don't hesitate to reach out to the amazing Core community for support!

You can connect with fellow developers and enthusiasts through:

- [**Discord**](https://discord.com/invite/coredaoofficial)
- [**Telegram**](https://t.me/CoreDAOTelegram)
- [**Github**](https://github.com/coredao-org)
- [**Twitter**](https://twitter.com/Coredao_Org)
- [**Core Dev Twitter**](https://x.com/corechain_devs)

These channels are a treasure trove of information, support, and inspiration. You'll find helpful tutorials, insightful discussions, and a welcoming community eager to help you succeed on your Core journey.

## Wrap Up

Core is more than just a blockchain; it's a movement, a community, and a vision for the future of Bitcoin.

With its robust technology, thriving ecosystem, and passionate community, Core is poised to redefine what's possible with Bitcoin. But the journey doesn't end here. We've explored how you can engage with this vibrant community, whether it's by learning, advocating, or even launching your own BTCfi venture.

But what if you're ready to get your hands dirty and start building on Core yourself? Get ready to level up, because, in our next chapter, we're diving into the world of development on Core. We'll equip you with the tools, resources, and knowledge you need to turn your ideas into reality and become an active contributor to this Bitcoin-powered revolution.

So, get those creative juices flowing, because the future of Bitcoin is being built right now, and you're invited to join the construction crew!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/1.%20Introduction%20to%20Building%20on%20Core/3.%20Exploring%20Core%20Programs.md

Exploring Core Programs

# Overview of Solidity and MetaMask

Welcome back devs! If you want to take full advantage of everything that Core has to offer and build some dope apps on Core, you’ll need to be able to interact with it. Just like how we’d use English or any other spoken language to chat and share our thoughts, we'll be using Solidity to code and interact with the Core blockchain.

Think of Solidity as the language that allows you to give instructions to the blockchain. But, to send those instructions and see the responses, you need a way to communicate with the blockchain in a secure and user-friendly manner. This is where MetaMask comes in.

[MetaMask](https://metamask.io/) is like your personal passport in the web3 world. Just like you need a passport to travel and prove your identity in different countries, MetaMask serves as your identity in the decentralized web. It allows you to securely store your crypto assets, manage your identities, and interact with decentralized applications (dApps) seamlessly.

In this lesson, we'll give you a solid overview of Solidity and show you how to set up your own MetaMask Wallet. With MetaMask, you'll be able to connect to the Core blockchain, deploy your smart contracts, and manage your crypto transactions with ease. So let's dive in and get started.

## What is Solidity?

Solidity is an object-oriented, high-level programming language used for writing smart contracts on EVM-compatible blockchains. It is a tool to generate machine-level code to execute on EVM. The solidity compiler takes the high-level code and breaks it down into simpler instructions. It is influenced by popular programming languages like C++, Python, and JavaScript.

Solidity is the first choice of development as it is specifically designed for creating smart contracts and interacting with EVM-compatible blockchains, like Core blockchain. This pretty much justifies the [$158 billion dollars of Total Value Locked (TVL)](https://defillama.com/languages) of Solidity language as of July 2024.

![img1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L4%20Image%201.webp?raw=true)

### Why Use Solidity?

- **Develop dApps**: Solidity is primarily used to create smart contracts, which are automated programs that enforce and verify agreements on the blockchain, essential for building secure, decentralized applications (dApps).
- **Immutable Contracts**: Smart contracts are transparent, tamper-proof, and can't be altered once deployed on the blockchain.
- **EVM Compatibility**: The Ethereum Virtual Machine (EVM) supports Solidity, making it a preferred choice for developers building on EVM-compatible blockchains like Core.
- **Versatile Use Cases**: Solidity enables a wide array of decentralized applications, from financial tools like lending platforms and decentralized exchanges, to creative pursuits like digital art (NFTs) and gaming, to governance systems like voting mechanisms and autonomous organizations.
- **Active Community and Support**: Benefit from a large, active community of developers, extensive documentation, and ongoing support for learning and troubleshooting.
- **Comprehensive Development Tools**: Leverage a variety of development tools and frameworks that integrate seamlessly with Solidity, making the development process more efficient and robust.

### Key Features

Solidity boasts a range of powerful features that make it ideal for creating smart contracts. Here are some of its standout features:

- **Object-Oriented**: Solidity is designed as an object-oriented programming language.
- **Supports Inheritance and Libraries**: You can reuse and extend your code through inheritance and libraries.
- **Function Modifiers and Events**: Solidity includes function modifiers and events to enhance functionality and track contract activity.
- **Built-In Data Structures**: It comes with built-in data structures and types such as mappings and arrays.
- **Open-Source**: Solidity is an open-source language, allowing for continuous improvement and community contributions.
- **Runs on Ethereum Virtual Machine (EVM)**: Solidity is executed on the Ethereum Virtual Machine, ensuring compatibility and security.

## Core and Solidity

Core isn't just a blockchain, it's a developer's playground. They are constantly pushing boundaries to make building their platform smooth and efficient.

![img2](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L4%20Image%202.webp?raw=true)

To ensure consistency and compatibility, Core supports all Solidity versions and EVM versions, however for solidity v0.8.19 and above it currently provides support using the Paris EVM. Don't fret, We'll guide you through the entire configuration process in the next lesson, making it easy for you to set up your project

So, that's the deal with Core and Solidity! Now that you know they work well together, let's jump into setting up your own MetaMask wallet.

## Creating Your Own MetaMask Wallet

Your MetaMask wallet is your key to the web3 world. With your MetaMask account, you can interact or communicate with the blockchain seamlessly. It's your digital wallet for storing, swapping, and buying cryptocurrencies, tokens, NFTs, and more.

MetaMask is available as a stand-alone mobile app and a Chrome browser extension. We'll be using the Chrome extension, as most of us will be developing in a desktop environment.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L4%20Image%203.webp?raw=true)

Here are the installation steps:

- Go to [MetaMask.io](https://metamask.io/).
- Click "Download for Chrome" and install the Chrome extension.
- Agree to the terms of use and conditions.
- Set up your secure password.
- Secure your 12-word recovery phrase properly and never share it with anyone.

Write down your recovery phrase and store it safely. If you lose it, there's no way to recover your account, so be very mindful.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L4%20Image%204.webp?raw=true)

Congrats🎉! your account has been created and now we will need to get two important pieces of data related to our account for us to publish our dApp.

1. Public Address
2. Private Key

To extract your public address and private key from the MetaMask Chrome extension, follow these steps:

- Open the MetaMask extension in your browser.
- Click on the three dots in the upper right corner of your account card.
- Select "Account details" from the dropdown menu.
- You'll see your **public address** displayed at the top. Copy it for later use.
- To export your **private key**, click on "Show private key."
- Enter your MetaMask password to confirm.
- Click and hold the button to reveal your private key.
- Copy your private key and store it securely. Remember, never share your private key with anyone.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L4%20Image%205.webp?raw=true)

We suggest keeping these pieces of information handy as we'll need them for upcoming lessons. Your MetaMask wallet serves as your gateway to the web3 world, enabling seamless interaction with the blockchain. Remember to safeguard your public address and private key securely, as they are essential for publishing your dApp and managing your digital assets.

## Wrap Up

Awesome job Guys 💪! In this lesson, we dived into the basics of Solidity and its key features, explored why it's the go-to language for developing on the Core, and set up our MetaMask wallet, your gateway to the web3 world. We also learned how to extract your public address and private key, which are essential for publishing your dApp.

Now that we have a solid foundation and our tools ready, we're all set to start setting up our development environment in the next lesson so that we are on our way to building our Lending dApp. Cheerio ✌️


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/2.%20Getting%20Started%20with%20Development%20on%20Core/1.%20Overview%20of%20Solidity%20and%20MetaMask.md

Overview of Solidity and MetaMask

# Setting Up the Development Environment

Hey there, future blockchain builders! So, you're eager to dive into the exciting world of Core development, huh? Awesome! This lesson is your personal tour guide, walking you through setting up your developer toolkit and even deploying your first smart contract on the Core testnet. Think of it as building your own blockchain laboratory! Don't worry if this is all new to you – we'll keep it chill and explain every step so you can follow along with ease.

By the end of this lesson, you'll have your very own coding playground ready to experiment with smart contracts, just like a kid with a brand-new LEGO set. And to celebrate your setup success, we'll deploy a simple "Hello World" contract to the Core testnet – your first step into the world of Core development!

## Tool Time: Gathering Your Gear

Before we dive into the coding fun, we need to gather some essential tools. Think of it like prepping your ingredients before baking a cake – you can't make deliciousness without the right stuff!

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%201.webp?raw=true)

1. **Node.js & npm (or yarn):** Think of Node.js as the engine that powers your JavaScript code, even outside of a web browser. This is super important for blockchain development because it allows you to interact with the Core network directly from your computer. npm (or yarn) is your trusty package manager. It's like a shopping cart for code libraries, making it easy to install and manage all the software components your project needs.
    - **Download & Install Node.js:** Head over to [nodejs.org](https://nodejs.org/) and grab the installer for your operating system (Windows, macOS, or Linux). The installer will also include npm (or you can choose to install yarn separately). Just follow the on-screen instructions. If you're not sure which one to choose, npm is a great starting point.
    - **Verify Success:** Open your terminal (or command prompt) and type the following commands:
        
        ```solidity
        node -v
        npm -v
        ```
        
        (If you're using yarn, run `yarn -v` instead of `npm -v`)
        
    
    You should see version numbers for both Node.js and your package manager printed out. If you do, congrats! You've successfully installed Node.js and your package manager.
    
2. **Visual Studio Code (VSCode):** This is our code editor of choice. It's a free, powerful tool that makes writing Solidity code (the language for smart contracts) a breeze. It's got a clean interface, tons of customization options, and a huge library of extensions to help you code like a pro.
    - **Download & Install:** Grab it from [code.visualstudio.com](https://code.visualstudio.com/) and follow the simple installation instructions.
    - **Power-Up:** Install the "Solidity" extension. This extension is a must-have for Solidity developers. It provides syntax highlighting (makes your code colorful and easier to read), code completion (suggests code as you type), and error checking (helps you catch mistakes early). You can find it in the VSCode extensions marketplace by searching for "Solidity."
        
    ![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%202.webp?raw=true)
            
3. **Git:** Git is a version control system that lets you track changes to your code, collaborate with others, and revert to previous versions if needed. It's like a time machine for your code!
    - **Download & Install:** Grab it from the official website: [git-scm.com](https://git-scm.com/) and follow the instructions.
        
        ![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%203.webp?raw=true)
        
4. **Git CLI:** It allows you to connect with your git from the terminal, so let’s install it too. You can follow the steps given [here](https://github.com/cli/cli). Once you have installed the Git CLI, let me tell you how you can configure your terminal with it.
    - Open your favorite terminal.
    - Run `gh --version` to ensure that you have installed the Git CLI successfully.
    - Run `gh auth login --web` in your terminal and follow the steps given below:
        1. First, it will ask for your preferred protocol for Git operations. I chose HTTPS, you can choose any.
        2. Second, it will ask you to Authenticate Git with your GitHub credentials, and type Y.
        3. Third, you will be able to see some code on your terminal. Copy it.
        4. Then, press Enter. It will open a window in your browser.
        5. Paste the code you copied and authorize your git. You might need to enter your GitHub password if you have yet to log in.
        6. Do not close this terminal!

    ![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%204.webp?raw=true)

Awesome, you are all set!! Good job!

## Adding the Core Testnet to MetaMask: Your Blockchain Playground

Imagine the Core testnet as your personal blockchain playground. You can experiment, test your dApps, and make mistakes without worrying about real-world consequences.

Let’s add it to MetaMask so you can access it:

1. **Open MetaMask:** Click on the little fox icon in your browser (or open the app).
2. **Network Dropdown:** Click the dropdown menu at the top where it usually says "Ethereum Mainnet."
3. **Custom RPC:** Scroll down and select "Add network".
4. This will open a tab in the browser, click on “Add network manually” there.
5. **Enter Details:** Fill in the following information, double-checking that it's correct:
    - **Network Name:** Core Testnet
    - **New RPC URL:** [https://rpc.test.btcs.network](https://rpc.test.btcs.network/)
    - **ChainID:** 1115
    - **Symbol:** CORE
6. **Save:** Hit "Save," and you're in! It will ask you to switch to the network, well switch!

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%205.webp?raw=true)

You can explore more Core Blockchain rpc links [here](https://docs.coredao.org/docs/Dev-Guide/rpc-list).

## Fetching Some Test tokens

Well, we know that we need test tokens to run any transaction on the blockchain, so let’s fetch some.

1. Head over to Core testnet faucet: [https://scan.test.btcs.network/faucet](https://scan.test.btcs.network/faucet).
2. Enter your wallet address which is the same public address we had copied up in the previous lesson.
3. Click on “Get tCORE”.
4. View your Metamask, you might have received 1 CORE.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%206.webp?raw=true)

## Your First Project

[Hardhat](https://hardhat.org/) is our secret weapon for smart contract development! It simplifies everything from testing your code to deploying it on the blockchain. You can think of it as your blockchain toolkit. Well, instead of building everything from scratch, we have made it easy for you by providing a boilerplate code. This will help you to start right away~

In the same terminal where you configured your Git CLI, run the following command:

```
gh repo fork https://github.com/0xmetaschool/build-lending-dapp-on-core.git --clone
```

This will clone the boilerplate code of your project onto your system and fork the repository to your Git account as well.

Now run these commands:

```
cd build-lending-dapp-on-core
npm install
```

This will download and install Hardhat, its dependencies, and other code libraries like `ether.js` that it needs to work.

Well, Ethers.js is a JavaScript library that allows developers to interact with EVM-based blockchains. It provides a range of utilities and abstractions to make it easier to work with smart contracts, manage wallets, and perform blockchain operations. It is essential for front-end interaction too. Don’t worry, we will explore it in upcoming lessons.

## Configuring Hardhat for Core

Now, let's tell Hardhat about our new playground (the Core testnet). This will allow it to connect to the network and deploy our contracts on the Core testnet.

**Open hardhat.config.js:** This file is like the control panel for Hardhat. You'll find it in your project's root directory. You will see we have a variable of `PRIVATE_KEY` there and we need to initialize somewhere, but yes, we want it **safe** so let me tell you a way how we can do it:

Create a `.env` file in `build-lending-dapp-on-core` folder and add the following content to it.

```
PRIVATE_KEY=" "
```

Do you remember, we copied our private key in the last lesson? Well, here we will use it. Paste the private key into your `.env` file in between the `“”`. And we are set!

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%207.webp?raw=true)

## Your First Smart Contract: Hello, Core!

We have created a simple "Hello World" contract to test if everything works as it should. Navigate to `build-lending-dapp-on-core/contracts/HelloWorld.sol`. There you will see a smart contract with the following code:

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

contract HelloWorld {
	string public message = "Hello, Core!";
}
```

## Compiling and Deploying

1. **Compile:** Run the following command to compile the code:
    
    ```
    npx hardhat compile
    ```
    
2. This translates your Solidity code into bytecode that the Core network can understand.
3. **Deployment Script:** In the `ignition/modules` folder of your project, you will find `deploy_hello_world.js` with the following code:
    
    ```
    const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
    module.exports = buildModule("HelloWorldModule", (m) => {
    	const HelloWorldContract = m.contract("HelloWorld", []);
    	return { HelloWorldContract };
    });
    ```
    
4. **Deploy:** In your terminal, run the following command. Type `y` for deployment and viola, it will be deployed.
    
    ```solidity
    npx hardhat ignition deploy ./ignition/modules/deploy_hello_world.js --network core_testnet
    ```
    
5. If everything is set up correctly, you'll see a message in your console indicating the address of your deployed "Hello World" contract. Congratulations! Your development environment is ready for building awesome dApps on Core.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L5%20Image%208.webp?raw=true)

## Wrap Up: You're a Blockchain Builder Now!

High-five, coding champ! You've just set up your Core Blockchain development environment like a pro. You've installed Node.js, VSCode, git, and Git CLI, connected your MetaMask wallet to the Core testnet, and even unleashed your first "Hello World" smart contract on the blockchain.

That wasn't so scary, was it? You're officially part of the growing community of Core Blockchain developers who are building the future of decentralized finance.

But remember, this is just the first step of your exciting journey. In our upcoming lessons, we'll tackle more advanced Solidity concepts, build out the functionality of our lending dApp, and explore how to create a user interface to interact with it. So keep that coding spark alive, because the possibilities on Core blockchain are endless!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/2.%20Getting%20Started%20with%20Development%20on%20Core/2.%20Setting%20up%20the%20Development%20Environment.md

Setting up the Development Environment

# Introduction to Lending dApp

Let’s now unveil what we are going to be building throughout this course. As we want to showcase Core’s security and innovative features, we thought of helping you guys create your own Lending dApp. And remember, in blockchain, every mistake is a new 'block' in your understanding! So, let's build something amazing and learn along the way.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L6%20Image%201.webp?raw=true)

## Features of Our Lending DApp

- **Stake USD to Borrow BTC:** Deposit **USD tokens** as collateral to borrow **BTC** tokens. It’s like putting down a deposit to access funds for various purposes within the Core DeFi ecosystem.
- **Collateralized Loans:** Maintain a minimum collateralization ratio to manage risk. For example, stake 1.5 USD to borrow 1 BTC.
- **Flexible Borrowing and Lending:**
    - **Borrowers:** Stake USD to receive BTC tokens and repay with interest within a designated timeframe.
    - **Lenders:** Lend BTC directly to borrowers and earn interest.
- **USD Deposits and Withdrawals:** Easily manage your USD deposits and withdrawals based on your lending or borrowing needs.
- **BTC Repayment:** Repay borrowed BTC tokens with interest to unlock your staked USD collateral.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L6%20Image%202.webp?raw=true)

Our Lending dApp lets you borrow BTC by staking USD as collateral, ensuring a safe collateralization ratio. You can also lend BTC for interest. Manage USD deposits easily, and repay borrowed BTC plus interest to unlock your collateral.

💡 **Note:** BTC and USD in this context are custom mock tokens for our development purposes. They are not actual cryptocurrencies. We'll also include a faucet within our dApp to obtain these tokens for free.

## The Checklist

We want to ensure that you can learn the concepts of Solidity and the process of publishing smart contracts onto the Core Blockchain, So we will visit all the core concepts and procedures while building our Lending dApp step by step. So If you're looking to create a checklist for bringing our Lending dApp to life, here's what you'll need:

✅ Using the basics of Solidity to build our starting smart contract from scratch.

✅ Using mappings to store all loans taken by borrowers.

✅ Creating functions to manage operations within our dApp.

✅ Utilizing interface and ERC20 standards to interact with USD and BTC tokens (more details on this later).

✅ Implementing constructors and operators to initialize your contract and manage operations efficiently.

✅ Implementing stake and borrow functions.

✅ Implementing functions for calculating interest and managing loan repayment.

✅ Ensuring our smart contract is secure from common vulnerabilities and understanding best practices for secure smart contract development.

## Wrap Up

And that's a wrap for this lesson! We have explored all the exciting functionalities our lending dApp will offer, from borrowing BTC with USD as collateral to lending BTC for interest and managing deposits and withdrawals.

We also discussed the steps we'll be taking next to build our dApp from scratch. In the upcoming lesson, we'll dive into the code and bring our project to life. Get ready to roll up your sleeves and create something amazing. See you there 🫡!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/3.%20Starting%20Lending%20dApp%20development%20on%20Core/1.%20Introduction%20to%20Lending%20dApp.md

Introduction to Lending dApp

# Solidity Basics and Writing the Contract Skeleton

Welcome back, people! It's time to take our first steps to create our smart contract for the lending dApp so that we can later set it free on the Core blockchain. Just like how you’ll need a keyboard to code, we need Solidity to communicate with the Core blockchain.

Now if you’re already familiar with Solidity then writing the contract is gonna be a breeze, if you aren’t familiar with Solidity then we got you, comrade 💪. We’ll quickly brief you on the basics of Solidity then we can go ahead to create our smart contract for the lending dApp and then deploy it to the testnet. So let’s kick off with the basics!

## The Solid Basics

Alright, let’s start with the basics. Head over to the `contracts` folder that will contain an empty file named `CoreLoanPlatform.sol`. This is the file where all the magic will happen.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L7%20Image%201.webp?raw=true)

Let’s start with a bare-bones contract containing only the following three things:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract CoreLoanPlatform {

}
```

- **License Identifier** The comment `SPDX-License-Identifier: MIT` is there to indicate that our code uses the MIT license. It’s kind of like putting a label on your work so everyone knows they can use it freely. This is important for open-source projects to clarify the licensing and usage rights.
- **pragma keyword** The `pragma` keyword is used to specify the version of Solidity that our code should be compiled with. Here, `pragma solidity ^0.8.24`; means we want our contract to work with Solidity version `0.8.24` or any newer version. This helps prevent compatibility issues with different compiler versions.
- **An empty contract named `CoreLoanPlatform`**
    
    This is where our contract starts taking shape. Right now, it's just an empty shell, but soon we'll be adding components and all the logic that will make our lending dApp work. Think of it as a blank canvas we will paint upon later.
    

## Contract Components

A typical Contract in Solidity will contain three things:

1. **State Variables**
2. **Functions**
3. **Events**

![Screenshot(35)](https://github.com/user-attachments/assets/120a31ef-aaca-410d-b911-1ae7bf5ea64b)


Let's start with understanding state variables and how to create them.

### State Variables

State variables in Solidity act as the vault for storing data on the blockchain. They persist throughout the contract's lifespan, residing within the contract itself but outside specific functions. In our lending dApp, these variables hold crucial details such as :

- Collateral ratio
- Interest rate
- Loan duration

We’ll create them as public state variables that can be accessed and modified by internal function calls in the contract. The syntax is simple: datatype followed by variable name. You can even assign the variable a value while declaring it as well.

```solidity
// <data-type> <variable-name> = <value>;
uint myVariable = 123;
```

Now that we are talking about data types, let’s address them a bit.

### Data Types

Solidity has value types (such as Integer or Boolean, which store actual data) and reference types (like addresses, which store pointers to data locations). Let’s focus on value types for now, we’ll go over reference types in the next lesson.

- **Signed/Unsigned Integers**: Integer data types store whole numbers, with signed integers storing both positive and negative values (`int`) and unsigned integers storing non-negative values (`uint`).
- **Booleans**: The Boolean data type is declared with the `bool` keyword and can hold only two possible constant values: `true` or `false`.
- **Addresses**: The `address` type is used to store a wallet or smart contract addresses, typically 20 bytes in size.
- **Byte Arrays**: Byte arrays, declared with the keyword `bytes`, are fixed-size arrays used to store a predefined number of bytes up to 32.
- **Enums**: Enums, short for Enumerable, are a user-defined data type that restricts the value of the variable to a particular set of constants defined within the program.

To store the collateral ratio, interest rate, and loan duration, we will use the `uint256` type and as these values are not to be changed then we’ll make them fixed using the `constant` keyword.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract CoreLoanPlatform {
	uint256 public constant COLLATERAL_RATIO = 150; // 150% collateralization
	uint256 public constant INTEREST_RATE = 5; // 5% interest rate
	uint256 public constant LOAN_DURATION = 30 days;
}
```

Let’s also create two more `uint256` variables to store the total amount of staked USD and the total amount of borrowed BTC as follows.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract CoreLoanPlatform {
	uint256 public constant COLLATERAL_RATIO = 150; // 150% collateralization
	uint256 public constant BORROWABLE_RATIO = 80; // 80% of collateral can be borrowed
	uint256 public constant INTEREST_RATE = 5; // 5% interest rate
	uint256 public constant LOAN_DURATION = 30 days;
	uint256 private totalStaked = 0; //Counter for total staked
	uint256 private totalBorrowed = 0; //Counter for total borrowed
}
```

Remember, we can use these variables inside of functions by following the same syntax, but they’ll be a local variable that can only be used within the function or block (the area between the curly braces.)

Let’s deploy this contract onto the testnet and see how it’d look. First, navigate to `./ignition/modules` folder and then update the contents of `deploy.js` to the following:

```solidity
const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
module.exports = buildModule("LoanDAppBasicModule", (m) => {
	const Contract = m.contract("CoreLoanPlatform", []);
	return { Contract };
});
```

Now, compile the contract using the following command:

```solidity
npx hardhat compile
```

Finally, let’s deploy our contract by running the following command in your terminal:

```solidity
npx hardhat ignition deploy ./ignition/modules/Deploy.js --network core_testnet
```

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L7%20Image%203.webp?raw=true)

This will deploy the CoreLoanPlatform contract to the Core testnet, and you'll receive a console message showing the deployment address of your contract. Copy the address and head over to [Core Testnet Scan](https://scan.test.btcs.network/). Paste the address in the search panel and you should be able to see your contract live in the Core blockchain.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L7%20Image%204.webp?raw=true)

## Contract Verification

Transparency and Trust are two of the cornerstones of blockchain technology. Our deployed contract currently needs to be verified. We’ll be guiding you through how you can verify your contract using the Core Explorer. Verifying our contract will make it so that users can trust its functionality, see exactly how it works, and ensure it hasn't been tampered with, enhancing the overall credibility and security of our platform. Follow the steps given below to verify your own contract.

**Note**: To align your smart contract with Core [Chain's guidelines](https://docs.coredao.org/docs/Dev-Guide/smart-contract-guidelines), ensure that the "evmVersion" parameter is set to "Paris" under the solidity compiler settings in hardhat.config

- On the Core Testnet Scan page for your contract, select the contract tab and click on the *Verify* and *publis*h* hyperlink.
- Fill in the needed details on the verification page, like:
    - Contract address: This field will be pre-filled.
    - Compiler type: We will be selecting "Single File" under Compiler type as our current contract is quite simple to begin with. In case if you end up creating complex contracts in the future, such as contracts with external imports, You’ll go with the Standard Json compiler type.
    - Compiler version: Select it as v0.8.24+
    - Open-source license type: License type of our contract will be *MIT License*.
- Click on the Continue button so as to proceed.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L7%20Image%205.webp?raw=true)

- Select *Yes* under the Optimization field.
- Enter your Smart contract code in the provided field.
- As we have not created any custom constructor for our contract yet, we can leave the Constructor Argument Field empty.
- Click on the *Verify and Publish* button to finish the process.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L7%20Image%206.webp?raw=true)

There we go, we have successfully verified our contract and your contract should be shown below in the Explorer.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L7%20Image%207.webp?raw=true)

## Wrap Up

In this lesson, we began building our smart contract for the lending dApp on the Core blockchain. Starting with Solidity basics, we defined key variables like collateral ratios and interest rates. We also saw the process to verify our contract on the Core Network. Next, we’ll focus on implementing storage solutions for loans and enhancing our dApp’s functionality. So, we’ll see you in the next lesson✌️.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/3.%20Starting%20Lending%20dApp%20development%20on%20Core/2.%20Solidity%20Basics%20and%20Writing%20the%20Contract.md

Solidity Basics and Writing the Contract Skeleton

# Struct, Mapping and Function in the dApp

Welcome back, aspiring blockchain developers! In our previous lesson, we laid the foundation for our lending dApp by setting up our project, importing essential libraries, and declaring the basic structure of our smart contract. We're on our way to creating a decentralized lending platform on Core blockchain!

Now, it's time to add some real functionality to our contract. In this lesson, we'll dive deeper into the world of Solidity and explore three crucial components for building dApps: structs, mappings, and functions. Think of structs as custom data types for organizing related data, mappings as your dApp's filing system, and functions as the actions your dApp can take. By mastering these concepts, you'll be equipped to build a robust and interactive lending platform.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L8%20Image%201.webp?raw=true)

By the end of this lesson, you'll have a solid understanding of how structs, mappings, and functions work together to create a simple yet functional lending dApp. So, grab your coding tools, and let's get building!

## Structs: Your Custom Data Containers

Now, in the real world, we often group related information. For instance, your medical records might contain your name, date of birth, medical history, and current medications. You wouldn't want this information scattered across random pieces of paper, would you?

In Solidity, structs are like personalized folders for your data. They let you bundle multiple variables of different types into a single, organized unit.

### Code Snippet: A Simple Struct

```solidity
struct Patient {
	string name;
	uint age;
	string medicalHistory;
}
```

In this example, the `Patient` struct acts like a medical record folder, holding a patient's name, age, and medical history in one place.

**Structs in Our Lending dApp**

We'll use a similar concept in our lending dApp with the `Loan` struct:

```solidity
struct Loan {
	uint256 amount;    // The amount of BTC borrowed
	uint256 collateral; // The amount of USD deposited as collateral
	uint256 timestamp;  // When the loan was taken out
	bool active;        // Whether the loan is still open
}
```

Think of this `Loan` struct as a mini-file that neatly organizes all the essential details about a particular loan:

- `amount`: The total amount of BTC tokens borrowed.
- `collateral`: The amount of USD tokens deposited as collateral.
- `timestamp`: The time (in seconds since the Unix epoch) when the loan was initiated. This helps us track the loan's duration.
- `active`: A boolean flag indicating whether the loan is still active (`true`) or has been repaid (`false`).

## Mappings: Your Smart Contract's Efficient Filing System

Now that we have a way to neatly package loan information using the `Loan` struct, how do we organize and access all these loans within our smart contract? That's where mappings come in.

Imagine you're running a books lending library, but instead of books, you're lending out shiny crypto coins. Mappings are like your high-tech filing cabinets, allowing you to efficiently store and retrieve information. However, in our lending dApp, we need two separate filing cabinets to keep track of different types of data.

### How Mappings Work

Let's quickly recap the structure of a mapping:

```solidity
mapping(KeyType => ValueType) public mappingName;
```

- `KeyType`: The unique identifier or label for each entry in the mapping.
- `ValueType`: The data associated with each key.
- `mappingName`: A descriptive name for the mapping.

### Mappings in Our Lending dApp

We'll use three mappings in our contract to efficiently store and manage data related to loans, lender balances, and user collateral:

1. **`loans`**: This mapping functions as a comprehensive record of all loan activities within our platform. The borrower's address (`address`) serves as the key, allowing us to quickly identify and retrieve the details of a specific loan. The value associated with each key is a `Loan` struct.
    
    ```solidity
    mapping(address => Loan) public loans;
    ```
    
2. **`lenderBalances`**: In our decentralized lending ecosystem, it's vital to maintain an accurate record of each lender's contributions. The `lenderBalances` mapping accomplishes this by associating each lender's address (`address`) with the total amount of BTC tokens they have deposited (`uint256`). This mapping is pivotal for:
    - Ensuring lenders can withdraw only the amount they've deposited.
    - Tracking the overall liquidity available for borrowing.
    - Calculating interest earned based on individual contributions.
    
    ```solidity
    mapping(address => uint256) public lenderBalances;
    ```
    
3. **`userCollateral`**: This mapping keeps track of the collateral each user has locked in the contract.
    
    ```solidity
    mapping(address => uint256) public userCollateral;
    ```
    

## Practical Examples

Let's illustrate how these mappings work with a couple of scenarios:

- **Scenario 1: Alice Takes Out a Loan** Alice decides to borrow 100 BTC tokens and deposits 150 USD as collateral. We would store this information in the `loans` mapping under Alice's address:
    
    ```solidity
    loans[Alice's Address] = Loan(100, 150, 1693526400, true);
    ```
    
- Also, we would update the collateral mapping:
    
    ```solidity
    userCollateral[Alice's Address] += 150;
    ```
    
- **Scenario 2: Bob Deposits BTC** Bob wants to lend out some BTC tokens and deposit 500 BTC into the platform. We would record this in the `lenderBalances` mapping:
    
    ```solidity
    lenderBalances[Bob's Address] = 500;
    ```
    

By utilizing these mappings effectively, our smart contract can efficiently manage loan records, lender balances, and user collateral deposits, ensuring transparency, security, and seamless operation of the lending platform.

## Functions: The Actions Your dApp Takes

Now that we have our data organized with mappings and structs, it's time to make our dApp do something! That's where **functions** come in. Functions are the actions your smart contract can perform, like accepting deposits, issuing loans, and calculating interest.

### Anatomy of a Function

```solidity
function functionName(parameters) visibilitySpecifier returns (returnTypes) {
	// The code that makes the function work
}
```

Let's break it down:

- **functionName:** A clear name that describes what the function does (e.g., `depositCollateral`).
- **parameters:** The inputs the function needs to work (e.g., the `amount` of USD being deposited).
- **visibilitySpecifier:** Who's allowed to call this function? It can be `public` (anyone), `external` (only from outside the contract), `internal` (only from within the contract or derived contracts), or `private` (only from within the same contract).
- **returnTypes:** The values the function gives back after it's done (e.g., a boolean `true` or `false` to indicate success or failure).

## Key Functions in Our Lending dApp

Now, let's take a look at all the major functions we are going to use in our Lending dApp

```solidity
function depositCollateral(uint256 amount) external;

function withdrawCollateral(uint256 amount) external;

function borrowBTC(uint256 amount) external;

function repayLoan(address user) external;

function depositBTC(uint256 amount) external;

function withdrawBTC(uint256 amount) external;

function calculateInterest(address user) external view returns (uint256);

function getBorrowableAmount(address user) external view returns (uint256);

function getLoanDetails(address borrower) external view returns (Loan memory);

function getLenderBalance(address lender) external view returns (uint256);

function getTotalStaked() external view returns (uint256);

function getTotalBorrowed() external view returns (uint256);

function getCurrentApy() external pure returns (uint256);

function getUserCollateral(address user) external view returns (uint256);

function getUserBorrowed(address user) external view returns (uint256);

function getUserStaked(address user) external view returns (uint256);
```

These functions handle the core actions of our lending platform:

- **depositCollateral(uint256 amount):** Lock up your USD tokens as collateral to borrow later.
- **withdrawCollateral(uint256 amount):** Get your USD back if you're not borrowing anything.
- **borrowBTC(uint256 amount):** Borrow some BTC, but only if you've got enough collateral.
- **repayLoan(address user):** Pay back your BTC loan, plus a little extra for interest.
- **depositBTC(uint256 amount):** Lend your BTC to the platform and let others borrow it.
- **withdrawBTC(uint256 amount):** Take back the BTC you lent out, anytime you want.
- **calculateInterest(address user):** See how much interest someone owes on their loan.
- **getBorrowableAmount(address user):** Check how much BTC someone can borrow based on their collateral.
- **getLoanDetails(address borrower):** Peek at all the juicy details of a particular loan.
- **getLenderBalance(address lender):** See how much BTC a lender has deposited.
- **getTotalStaked():** Get the grand total of all BTC staked in the platform.
- **getTotalBorrowed():** See the combined amount of BTC currently on loan.
- **getCurrentApy():** Check out the annual percentage yield (APY) lenders can earn.
- **getUserCollateral(address user):** Find out how much USD collateral a user has stashed.
- **getUserBorrowed(address user):** Check how much BTC a user has borrowed.
- **getUserStaked(address user):** Check how much BTC a user is lending out.

By now, our smart contract should look something like this. You can copy the following code and paste it into the `CoreLoanPlatform.sol` file within the `contracts` folder of your project directory.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract CoreLoanPlatform {

	// Constants for loan parameters (values will be added later)
	uint256 public constant COLLATERAL_RATIO = 150; // 150% collateralization
	uint256 public constant BORROWABLE_RATIO = 80; // 80% of collateral can be borrowed
	uint256 public constant INTEREST_RATE = 5; // 5% interest rate
	uint256 public constant LOAN_DURATION = 30 days;
	uint256 private totalStaked = 0; //Counter for total staked
	uint256 private totalBorrowed = 0; //Counter for total borrowed
	
	//Loan Struct
	struct Loan {
	uint256 amount;
	uint256 collateral;
	uint256 timestamp;
	bool active;
	}

	// Mappings to store loan and balance data
	mapping(address => Loan) public loans;
	mapping(address => uint256) public lenderBalances;
	mapping(address => uint256) public userCollateral;

	function depositCollateral(uint256 amount) external {
		// TODO : Implement Logic for depositing Collateral
	}

	function withdrawCollateral(uint256 amount) external {
		// TODO : Implement Logic for withdrawing Collateral
	}

	function borrowBTC(uint256 amount) external {
		// TODO : Implement Logic for borrowing BTC
	}

	function repayLoan(address user) external {
		// TODO : Implement Logic for repaying Loan
	}

	function depositBTC(uint256 amount) external {
		// TODO : Implement Logic for depositing BTC
	}

	function withdrawBTC(uint256 amount) external {
		// TODO : Implement Logic for withdrawing BTC
	}

	function calculateInterest(address user) external view returns (uint256) {
		// TODO : Implement Logic for calculating interest
	}

	function getBorrowableAmount(address user) external view returns (uint256) {
		// TODO : Implement Logic for fetching borrowable amount
	}

	function getLoanDetails(address borrower) external view returns (Loan memory) {
		// TODO : Implement Logic for fetching loan of specific borrower
	}

	function getLenderBalance(address lender) external view returns (uint256) {
		// TODO : Implement Logic for getting the Lender balance
	}

	function getTotalStaked() external view returns (uint256) {
		// TODO : Implement Logic for fetching total staked amount
	}

	function getTotalBorrowed() external view returns (uint256) {
		// TODO : Implement Logic for fetching total borrowed amount
	}

	function getCurrentApy() external pure returns (uint256) {
		// TODO : Implement Logic for fetching current APY
	}

	function getUserCollateral(address user) external view returns (uint256) {
		// TODO : Implement Logic for fetching user's collateral amount
	}

	function getUserBorrowed(address user) external view returns (uint256) {
		// TODO : Implement Logic for fetching a User's borrowed amount
	}

	function getUserStaked(address user) external view returns (uint256) {
		// TODO : Implement Logic for fetching a User's Staked amount
	}

}
```

For now, the functions are just placeholders to help us define the contract's structure. As we progress through these lessons, we'll add the real code that makes our lending dApp actually do stuff, like transfer tokens and calculate interest.

Also, notice how each function is marked as `external`. This is like putting a "members only" sign on your dApp's front door – it means these functions can only be called by someone *outside* the contract, like a user's wallet. This adds an extra layer of security, ensuring that only authorized actions can be performed on our platform.

To make sure that everything is proper with our contract, let's just go ahead and do a little test deployment of it using hardhat.

## Compiling and Deploying Your Contract Using Hardhat

Now for the exciting part: bringing your contract to life! We'll use Hardhat, a development environment for Ethereum and EVM-compatible chains like Core blockchain, to compile and deploy our contract.

**1. Compile:**

Open your terminal and navigate to your project directory (where your Solidity contract file, `CoreLoanPlatform.sol`, is located). Then, run the following command:

```solidity
npx hardhat compile
```

This command will compile your Solidity code into bytecode, the low-level representation that the blockchain can understand and execute.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L8%20Image%202.webp?raw=true)

In case you see any warnings during the compilation step, Don't worry. We will fix them as we go along.

**2. Deploy (to the Testnet):**

Now that your contract is compiled, it's time to deploy it to the Core testnet. Testnets are safe environments where you can experiment and test your dApp without using real funds. They're like a playground for developers!

**2.1 Create a Deployment Script:**

In your Hardhat project directory, navigate to the `ignition/modules/Deploy.js`. Paste the following code in it:

```solidity
const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
module.exports = buildModule("CoreLoanPlatform", (m) => {
	const CoreLoanPlatform = m.contract("CoreLoanPlatform");
	return { CoreLoanPlatform };
});
```

**2.2 Configure Hardhat:**

Make sure your `hardhat.config.js` file has the correct network configuration for the Core testnet. You'll need to add the RPC URL and other relevant details. We have already added for you:

```solidity
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: {
		core_testnet: {
			url: "https://rpc.test.btcs.network",
			accounts: privateKey(),
		},
	},
	solidity: {
		version: "0.8.24",
		settings: {
			evmVersion: 'paris',
			optimizer: {
				enabled: true,
				runs: 1000,
			},
		},
	},
};
```

**2.3 Deploy the Contract:**

Before you deploy, make sure to delete the `./ignition/deployments` folder if it exists. Now, run the following command in your terminal:

```solidity
npx hardhat ignition deploy ./ignition/modules/Deploy.js --network core_testnet
```

This will deploy your `CoreLoanPlatform` contract to the Core testnet. You'll see a message in your console indicating the address where your contract is deployed.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L8%20Image%203.webp?raw=true)

Remember, the functions in our contract are currently just placeholders. We'll add the actual logic in upcoming lessons. This deployment step is just to verify that our contract compiles and deploys without errors.

## Pushing it to Git

Alright, now that we have a working contract on our hands, let's just go ahead and push all our progress to your git repository. To do that, use the same terminal or open a new one in the root directory of the project and run the following commands:

```solidity
git add .
git commit -m "code update"
git push
```

Now, you can be as specific as you want with the commit message ( `-m "<message>"`). The important thing is to actually push the code to the repository and record your progress in the Core development journey.

## Wrap Up

Congratulations, you've just built the scaffolding for your very own decentralized lending dApp on Core blockchain! We've laid the groundwork by organizing our data with mappings, defining the actions our dApp can take with functions, and even creating a basic structure for our `Loan` data. We've even taken the first step toward bringing our dApp to life by successfully compiling and deploying this contract to the Core testnet.

But remember, this is just the skeleton. The real magic happens when we add the logic that makes our dApp function like a well-oiled lending machine. In our upcoming lessons, we'll tackle that challenge head-on, filling in the function bodies with code that handles collateral deposits, loan approvals, interest calculations, and repayments. Get ready to transform this blueprint into a fully functional lending platform!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/3.%20Starting%20Lending%20dApp%20development%20on%20Core/3.%20Mapping%20and%20Function%20in%20the%20dApp.md

Mapping and Function in the dApp


# Using Interface and ERC20

Welcome back, code adventurers! In our journey till now, we built the basic skeleton of our lending dApp. Now, we're about to level up our Solidity skills with another two essential tools: interfaces and the ERC20 token standard. Don't worry if these sound a bit like magical incantations at first – we'll break them down in a way that's easy to understand.

Think of interfaces as blueprints that show how different smart contracts can chat with each other, and the ERC20 standard as the universal language spoken by most tokens in the blockchain world. By mastering these concepts, you'll be able to create more sophisticated and interoperable dApps on Core blockchain. It's like learning the secret handshake to the coolest blockchain club!

## The ERC20 Standard: The Universal Language of Tokens

Imagine you're in a bustling marketplace filled with vendors from all over the world. Each vendor speaks a different language, making it challenging to trade goods. But what if there was a universal language that everyone understood? That's exactly what the ERC20 standard is for tokens in the blockchain world.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%201.webp?raw=true)

ERC20 is a set of rules that defines how tokens should behave. It's like a universal dictionary that outlines the essential vocabulary and grammar for tokens to interact with each other. These rules cover everything from how tokens are transferred between addresses to how you can check your token balance. By adhering to the ERC20 standard, token creators ensure that their tokens can be easily used across different platforms and applications, promoting interoperability and creating a more unified token ecosystem.

### Why ERC20 is Awesome for Our Lending dApp

Think of it this way: if every token spoke its own unique language, building a dApp that could interact with them all would be a nightmare! It'd be like trying to understand a conversation between people speaking French, Mandarin, and Spanish all at the same time.

But thanks to the ERC20 standard, our lending dApp can work with any token that follows the rules. It's like having a universal translator for the blockchain world! This makes our dApp super flexible and adaptable.

## Interfaces: Your dApp's Communication Protocol

Now that we understand the importance of the ERC20 standard (that universal language for tokens), let's figure out how our smart contract actually talks to these tokens. This is where interfaces come in, and they're pretty awesome!

Imagine you're a language whiz who speaks every language on Earth. You walk into a bustling international marketplace. You can chat with the French pastry chef, haggle with the Egyptian spice merchant, and even order sushi from the Japanese fishmonger – all in their native languages!

**Interfaces are like your multilingual skills for smart contracts.** They let your contract "speak" the language of other contracts, even if they were written differently or by different developers. This is especially important when you're dealing with tokens.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%202.webp?raw=true)

### How do Interfaces Work?

Think of an interface as a blueprint or a contract. It defines a set of functions that any smart contract claiming to follow a certain standard (like ERC20) *must* have. But here's the cool part: the interface doesn't tell those contracts *how* to implement the functions, just that they *have* to have them.

**Code Snippet: Interface Example**

```solidity
interface IERC20 {
	function transfer(address recipient, uint256 amount) external returns (bool);
	function balanceOf(address account) external view returns (uint256);
	function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
	
	// ... other functions ...
}
```

In this snippet, we're defining an interface called `IERC20`. This is the standard interface for ERC20 tokens – like a rulebook they all agree to follow. Notice how it only outlines the *signatures* of the functions (their names, inputs, outputs) but not the actual code that makes them work. That's the beauty of interfaces! They let contracts talk to each other without needing to know all the nitty-gritty implementation details.

Let's break down some key functions defined in the `IERC20` interface:

- **transfer(address to, uint256 amount):** This function is used to transfer a specified `amount` of tokens from the caller's address to another address (`to`).
    
    ![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%203.webp?raw=true)
    
- **balanceOf(address account):** This function retrieves the token balance of a specific account.
    
    ![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%204.webp?raw=true)
    
- **transferFrom(address from, address to, uint256 amount):** This function allows you to transfer tokens from one address (`from`) to another (`to`) on behalf of the original owner (from), provided you've been given permission (`allowance`) to do so.
    
    ![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%205.webp?raw=true)
    

## Immutable Variables: Setting Things in Stone

In Solidity, immutable variables are like setting things in stone. They're constant values that are defined once when the contract is created and can never be changed. This is perfect for things like:

- **Contract Parameters:** Maybe the interest rate on loans or the minimum collateral ratio shouldn't change once the dApp is live. Immutables ensure these rules are set in stone.
- **Token Addresses:** You wouldn't want someone accidentally (or maliciously) changing the address of the token your dApp uses, right? Immutables keep these addresses locked in.

## Applying Interfaces and Immutables to Our Lending dApp

Now that we've got a solid grasp on interfaces (our communication blueprints for smart contracts) and immutables (our unchangeable constants), it's time to see how they work together in our lending dApp. We'll be using the `IERC20` interface as our bridge to interact with the tokens that users will lend and borrow (`USD` and `BTC` in this case). And, to make sure our lending rules stay rock solid, we'll use immutable variables to lock down key parameters like interest rates and collateral requirements.

```solidity
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract CoreLoanPlatform {
	// Interface Variables
	IERC20 public immutable USD;
	IERC20 public immutable BTC;
}
```

Let's break this code down:

**The ERC20 Connection**

First, we import the `IERC20` interface from OpenZeppelin, a reputable library of battle-tested smart contracts. This interface is like a universal translator that allows our contract to understand and interact with any `ERC20` token.

**Our Token Champions: USD and BTC**

Next, we declare two special variables called `USD` and `BTC`. They are of the `IERC20` type, which means they're not just basic addresses but powerful tools that know how to "talk" to `ERC20` tokens. We want our dApp to specifically work with `USD` (a stablecoin on Core blockchain) as collateral and `BTC` as the borrowing asset.

Notice the `public immutable` keywords:

- **public:** This means anyone can see the addresses of the USD and BTC contracts that our dApp is using. Transparency is key in the world of decentralized finance!
- **immutable:** This is like putting these addresses in a safety deposit box. Once set in the constructor, they can't be changed – ever! This is crucial for security, preventing any funny business like someone trying to swap out your trusted tokens for dodgy ones.

## Our Lending dApp Smart Contract (So Far)

Let's take a look at how our smart contract is shaping up with the concepts we've discussed: interfaces, the ERC20 standard, immutables, mappings, structs, and function outlines:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract CoreLoanPlatform {

	// Interfaces for ERC20 tokens
	IERC20 public immutable USD;
	IERC20 public immutable BTC;

	// Loan Parameters (Immutable Constants)
	uint256 public constant COLLATERAL_RATIO = 150; // 150% collateralization
	uint256 public constant BORROWABLE_RATIO = 80; // 80% of collateral can be borrowed
	uint256 public constant INTEREST_RATE = 5; // 5% interest rate
	uint256 public constant LOAN_DURATION = 30 days;
	uint256 private totalStaked = 0; //Counter for total staked
	uint256 private totalBorrowed = 0; //Counter for total borrowed

	// Loan Struct
		struct Loan {
		uint256 amount;    // Amount of USD borrowed
		uint256 collateral;   // Amount of BTC deposited as collateral
		uint256 startTimeStamp; // Timestamp of loan initiation
		bool active;      // Status of the loan (true = active, false = repaid)
	}
	
	// Mappings to Store Loan and Balance Data
	mapping(address => Loan) public loans;  // Maps borrower's address to their loan details
	mapping(address => uint256) public lenderBalances; // Maps lender's address to their BTC balance
	
	// Function Declarations (Placeholders)
	function depositCollateral(uint256 amount) external {
	// TODO : Implement Logic for deposting Collateral
	}
	
	function withdrawCollateral(uint256 amount) external {
	// TODO : Implement Logic for withdrawing Collateral
	}
	
	function withdrawBTC(uint256 amount) external {
	// TODO : Implement Logic for withdrawing BTC
	}
	
	function getBorrowableAmount(address user) external view returns (uint256) {
	// TODO : Implement Logic for fetching borrowable amount
	}
	
	function getUserCollateral(address user) external view returns (uint256) {
	// TODO : Implement Logic for fetching user's collateral amount
	}
	
	function borrowBTC(uint256 amount) external {
	// TODO : Implement Logic for borrowing BTC
	}
	
	function depositBTC(uint256 amount) external {
	// TODO : Implement Logic for deposting BTC
	}
	
	function repayLoan(address user) external {
	// TODO : Implement Logic for repaying Loan
	}
	
	function calculateInterest(address user) external view returns (uint256) {
	// TODO : Implement Logic for calculating interest
	}
	
	function getLoanDetails(address borrower) external view returns (Loan memory) {
	// TODO : Implement Logic for fetching loan of specific borrower
	}
	
	function getLenderBalance(address lender) external view returns (uint256) {
	// TODO : Implement Logic for getting the Lender balance
	}
	
	function getTotalStaked() external view returns (uint256) {
	// TODO : Implement Logic for fetching total staked amount
	}
	
	function getTotalBorrowed() external view returns (uint256) {
	// TODO : Implement Logic for fetching total borrowed amount
	}
	
	function getCurrentApy() external pure returns (uint256) {
	// TODO : Implement Logic for fetching current APY
	}
	
	function getUserBorrowed(address user) external view returns (uint256) {
	// TODO : Implement Logic for fetching a User's borrowed amount
	}
	
	function getUserStaked(address user) external view returns (uint256)  {
	// TODO : Implement Logic for fetching a User's Staked amount
	}

}
```

## Compiling and Deploying Your Upgraded Contract

Now that you've added interfaces and immutables to your contract, it's time to compile and deploy it! Follow these steps:

**Compile:**

```solidity
npx hardhat compile
```

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%206.webp?raw=true)

**Write the Deploy Script:**

Now in the `ignition/modules/Deploy.js` file, paste the following code for deploying your contract

```solidity
const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");
module.exports = buildModule("CoreLoanPlatform", (m) => {
	const CoreLoanPlatform = m.contract("CoreLoanPlatform");
	return { CoreLoanPlatform };
});
```

**Deploy to a Testnet:**

Once the `Deploy.js` script is set, make sure you remove the `./ignition/deployments` folder if it exists and then open a terminal in the root directory of your project and run the following command:

```solidity
npx hardhat ignition deploy ./ignition/modules/Deploy.js --network core_testnet
```

This will return the following output:

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L9%20Image%207.webp?raw=true)

## Pushing It to Git

As always, remember to push your to your github repository using the following commands:

```solidity
git add .
git commit -m "code update"
git push origin HEAD:refs/heads/Branch1
```

## Wrap Up


We've now laid the groundwork for our lending dApp. In our next exciting lesson, we'll finally start adding real logic to our functions. We'll cover everything from depositing and withdrawing collateral to calculating interest and processing loan repayments. Be ready to transform your contract from a blueprint into a fully functional lending platform!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/4.%20Interface%20and%20ERC20%20standard/1.%20Using%20Interface%20and%20ERC20.md

Using Interface and ERC20

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/4.%20Interface%20and%20ERC20%20standard/2.%20Constructor%20and%20Operators.md

Constructor and Operators


# Implement Stake and Borrow Functions

Alright, now that we’ve created functions for depositing and withdrawing collateral, let’s focus on making it so that we can stake our BTC tokens and also be able to withdraw them whenever needed.

## Quick Checkout

First things first, let’s quickly swap out our boilerplate with the corresponding front end for these functionalities.

```solidity
git checkout origin/boilerplate03
```

Don't worry, all the code we’ve written so far will be present in the project. Navigate to the `CoreLoanPlatform.sol` file present inside the `contracts` folder and let’s add the required functions there.

## Deposit Your BTC

Let’s get started with our `depositBTC()` function, this function should check whether the amount to be deposited is valid i.e. it must be greater than 0, and then transfer the amount from the sender to our contract.

For this purpose, we will be using the `safeTransferFrom()` function from the [SafeERC20](https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/utils/SafeERC20.sol) contract. This version of the `TransferFrom` function is more secure and reliable because it reverts on failure, checks the transfer return value, and protects against non-standard ERC20 implementations. We will go through these in detail in the upcoming lessons.

```solidity
function depositBTC(uint256 amount) {
	require(amount > 0, "Amount must be greater than 0");
	BTC.safeTransferFrom(msg.sender, address(this), amount);
}
```

Now we can update the lender’s balances by adding the amount deposited to it and then go ahead to increase the total staked value by the same amount passed to it.

```solidity
function depositBTC(uint256 amount) {
	require(amount > 0, "Amount must be greater than 0");BTC.safeTransferFrom(msg.sender, address(this), amount);
	lenderBalances[msg.sender] += amount;
	totalStaked = totalStaked + amount;
}
```

Finally, let’s make our `depositBTC()` function `external` so that we can allow external entities like users or contracts to initiate the deposit of BTC to our lending dApp. We will also emit the BTC Deposited event once all the tasks are over.

```solidity
function depositBTC(uint256 amount) external {
	require(amount > 0, "Amount must be greater than 0");
	BTC.safeTransferFrom(msg.sender, address(this), amount);
	lenderBalances[msg.sender] += amount;
	totalStaked = totalStaked + amount;
	emit BTCDeposited(msg.sender, amount);
}
```

## Withdraw Your BTC

To allow a user to withdraw their staked BTC, we first and foremost need to ensure that the amount is valid and that the user has staked enough BTC so that the amount is available to withdraw.

```solidity
function withdrawBTC(uint256 amount) external {
	require(amount > 0, "Amount must be greater than 0");
	require(lenderBalances[msg.sender] >= amount, "Insufficient balance");
}
```

We then update the lender's balance and the total staked amount by reducing both the amount being withdrawn.

```solidity
function withdrawBTC(uint256 amount) external {
	require(amount > 0, "Amount must be greater than 0");
	require(lenderBalances[msg.sender] >= amount, "Insufficient balance");
	lenderBalances[msg.sender] -= amount;
	totalStaked = totalStaked - amount;
}
```

Finally, let’s transfer the `amount` to the user and emit the `BTCWithdrawn` event.

```solidity
function withdrawBTC(uint256 amount) external {
	require(amount > 0, "Amount must be greater than 0");
	require(lenderBalances[msg.sender] >= amount, "Insufficient balance");
	lenderBalances[msg.sender] -= amount;
	totalStaked = totalStaked - amount;
	BTC.safeTransfer(msg.sender, amount);
	emit BTCWithdrawn(msg.sender, amount);
}
```

And with that, we've successfully written the logic to allow a user to withdraw an amount of BTC that was previously staked.

## Query Helper Functions

Finally, we’ll just add two more functions to our contract that will help us fetch the user’s staked amount and the current APY.

```solidity
function getUserStaked(address user) external view returns (uint256) {
	return lenderBalances[user];
}

function getCurrentApy() external pure returns (uint256) {
	return INTEREST_RATE;
}
```

This pretty much sums up all the functionalities we will need for the lending functionality, let’s deploy and test everything out.

## Let’s Try It Out

First, let’s create a `.env` in the root directory and paste in your private key against the `PRIVATE_KEY` variable.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L11%20Image%201.webp?raw=true)

Now let’s install all the dependencies and compile our contract using:

```solidity
npm install
npx hardhat compile
```

Let’s deploy our contract using hardhat ignition. Remove the `./ignition/deployments` folder if it exists and run the following command:

```solidity
npx hardhat ignition deploy ./ignition/modules/Deploy.js --network core_testnet
```

Copy the addresses of DAPP, USD, and BTC contract addresses from the terminal and paste them against the corresponding variables in the `.env` file present inside `*./interface/`* folder*.*

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L11%20Image%202.webp?raw=true)

Navigate to the react app and install the dependencies :

```solidity
cd interface
npm install
```

Copy the .json files containing the ABI from `*./artifacts/contracts*` to `*./interface/src/ABI/*` folder. You'll need to copy the following .json files from their respective folders

- Bitcoin.json
- CoreLoanPlatform.json
- IERC20.json
- USD.json

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L11%20Image%203.webp?raw=true)

Finally, let’s launch the front using:

```solidity
npm start
```

### Let’s Stake Our BTC

Time to test out the functionalities we have added into our app. Follow the given steps to do so:

- Connect your wallet by clicking on the *Connect Wallet* button
- Use the faucet to get 100USD and 10BTC Tokens
- Enter stake amount (≤ 10 BTC) and click on *Stake* Button
- Approve the transaction in the MetaMask popup that appears.
- Withdraw some of the staked amount by specifying it in the provided input field and pressing the withdraw button.
- Approve the transaction in the MetaMask popup that appears.

![withdraw-Fasr](https://github.com/user-attachments/assets/bb0be7bf-dfa8-4723-a678-5996923c465c)


And that’s it, our app now allows users to stake their BTC and withdraw it whenever they wish.

## Pushing It to Git

Make sure you are in `build-lending-dapp-on-core` folder.

As always, remember to push your code to your GitHub repository using the following commands.

```solidity
git add .
git commit -m "code update"
git push origin HEAD:refs/heads/Branch3
```

## Wrap Up

Our app now lets users stake and withdraw their BTC tokens whenever they want. We've added and tested functions to handle deposits and withdrawals, updated balances, and emitted events, and created helper functions to fetch user balances and current APY. With these features in place, our lending dApp is inching closer to its completion. We’ll add the remaining pieces up in the next lesson, we’ll see you there.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/4.%20Interface%20and%20ERC20%20standard/3.%20Implement%20Stake%20and%20Borrow%20functions.md

Implement Stake and Borrow Functions

# Implement Functions for Calculating Interest and Loan Repayment

Hey y’all! we’re now at the endgame, we've assembled most of the core functionalities of our lending dApp. Now, it's time to suit up and make sure our dApp can help users repay their loans and retrieve their collateral without a hitch. Once we complete this mission, our dApp will be complete and ready to rock. So let’s make it happen! 👌

## Quick Checkout

Just like before let’s quickly swap out our boilerplate with the corresponding frontend with all the functionalities.

```solidity
git checkout origin/boilerplate04
```

## Clearing Up the Debts

Let’s start by creating an external function called `replayLoan`, this function will take the address of the user as its parameter whilst performing all checks and operations required for the Loan repayment.

```solidity
function repayLoan(address user) external  {
	// Code goes here
}
```

The very first thing we need to do is to check if the user i.e. `msg.sender` has an active loan and also whether that user hasn’t exceeded the loan duration. We can easily get this sorted by

- First, fetching the loan of the user from our `loans` mapping.
- Then, verify if the `active` field of `loan` object is true, in case it’s false then the user doesn’t have any active loans
- Lastly, ensure that the loan duration (30 days) has not been exceeded. Calculate `daysElapsed` by finding the difference between `block.timestamp` and the loan's `timestamp` field. This difference gives the elapsed time in seconds, which we then divide by `SECONDS_IN_A_DAY` (86400) to get the days elapsed.

```solidity
function repayLoan(address user) external {
	Loan storage loan = loans[msg.sender];
	require(loan.active, "No active loan");
	uint256 daysElapsed = (block.timestamp - loan.timestamp) / SECONDS_IN_A_DAY;
	require(daysElapsed <= 30, "Loan duration exceeded 30 days");
}
```

Now we calculate the total interest on the `loan.amount` using the `INTEREST_RATE` constant and `daysElapsed`. Since `INTEREST_RATE` is annual, for a single day it equates to `INTEREST_RATE / 365`.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%201.webp?raw=true)

By adding the `interest` to `loan.amount`, we can also calculate the total amount to be repaid.

```solidity
function repayLoan(address user) external {
	Loan storage loan = loans[user];
	require(loan.active, "No active loan");
	uint256 daysElapsed = (block.timestamp - loan.timestamp) / SECONDS_IN_A_DAY;
	require(daysElapsed <= 30, "Loan duration exceeded 30 days");
	uint256 interest = (loan.amount * INTEREST_RATE * daysElapsed) / 36500;
	uint256 totalRepayment = loan.amount + interest;
}
```

## Core-cting Debts

Now all that’s left for us to do is to receive back the BTC that was borrowed and update the concerned fields.

Using the `safeTransferFrom` function (more on these in the next lesson), we securely send the `totalRepayment` amount to our smart contract. `safeTransferFrom` is reliable because it includes extra checks to prevent accidental transfers. If any conditions aren't met like insufficient funds then the transfer is automatically reverted, ensuring tokens are never lost

```solidity
function repayLoan(address user) external {
	Loan storage loan = loans[user];
	require(loan.active, "No active loan");
	uint256 daysElapsed = (block.timestamp - loan.timestamp) / SECONDS_IN_A_DAY;
	require(daysElapsed <= 30, "Loan duration exceeded 30 days");
	uint256 interest = (loan.amount * INTEREST_RATE * daysElapsed) / 36500;
	uint256 totalRepayment = loan.amount + interest;
	BTC.safeTransferFrom(user, address(this), totalRepayment);
}
```

Now we can change the `active` field of the loan to false, indicating that the loan is now inactive. Let’s also decrease the `totalBorrowed` by loan amount and finally emit the `LoanRepaid` event to broadcast that the Loan repayment is successful. This is how our function will look at the end.

```solidity
function repayLoan(address user) external {
	Loan storage loan = loans[user];
	require(loan.active, "No active loan");
	uint256 daysElapsed = (block.timestamp - loan.timestamp) / SECONDS_IN_A_DAY;
	require(daysElapsed <= 30, "Loan duration exceeded 30 days");
	uint256 interest = (loan.amount * INTEREST_RATE * daysElapsed) / 36500;
	uint256 totalRepayment = loan.amount + interest;
	BTC.safeTransferFrom(user, address(this), totalRepayment);
	loan.active = false;
	totalBorrowed = totalBorrowed - loan.amount;
	emit LoanRepaid(msg.sender, loan.amount, interest);
}
```

## Some More Query Helper Functions

Let’s quickly implement additional functions to retrieve details stored in our contract.

- **calculateInterest(address user)**: Calculates interest on an active loan for a specific user.
- **getLoanDetails(address borrower)**: Retrieves details of an active loan for a specific borrower.
- **getLenderBalance(address lender)**: Retrieves the current balance of BTC deposited by a lender.
- **getTotalStaked()**: Retrieves the total amount of BTC currently staked across all lenders.
- **getTotalBorrowed()**: Retrieves the total amount of BTC borrowed by all users.
- **getUserBorrowed**: This function returns the amount borrowed by a specific user if they have an active loan, or 0 if they don't. It checks if the user has an active loan and returns the borrowed amount if so.

```solidity
function calculateInterest(address user) external view returns (uint256) {
	Loan storage loan = loans[user];
	if (loan.active) {
		uint256 daysElapsed = (block.timestamp - loan.timestamp) / SECONDS_IN_A_DAY;
		uint256 interest = (loan.amount * INTEREST_RATE * daysElapsed) / 36500;
		return interest;
	}
}

function getLoanDetails(address borrower) external view returns (Loan memory) {
	return loans[borrower];
}

function getLenderBalance(address lender) external view returns (uint256) {
	return lenderBalances[lender];
}

function getTotalStaked() external view returns (uint256) {
	return totalStaked;
}

function getTotalBorrowed() external view returns (uint256) {
	return totalBorrowed;
}

function getUserBorrowed(address user) external view returns (uint256) {
    Loan storage loan = loans[user];
    if (loan.active) {
        return loan.amount;
    }
    return 0;
}
```

## Let’s Fire Up the DApp

You’ll need to follow the same steps as in the previous lessons to get things running. We’ll drop the same set of instructions here as well for you guys to follow.

First, let’s create a `.env` in the root directory and paste in your private key against the `PRIVATE_KEY` variable.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%202.webp?raw=true)

Now let’s install all the dependencies and compile our contract using :

```solidity
npm install
npx hardhat compile
```

Let’s deploy our contract using hardhat ignition. Remove the `./ignition/deployments` folder if it exists and run the following command:

```solidity
npx hardhat ignition deploy ./ignition/modules/Deploy.js --network core_testnet
```

Copy the addresses of **DAPP, USD, and BTC** Contract addresses from Terminal and paste them against the corresponding variables in the **`.env`** file present inside `*./interface/folder.*`

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%203.webp?raw=true)

Navigate to the react app and install the dependencies :

```solidity
cd interface
npm install
```

Copy the .json files containing the ABI from `*./artifacts/contracts*` to `*./interface/src/ABI/*` folder. You'll need to copy the following `.json` files from their respective folders

- Bitcoin.json
- CoreLoanPlatform.json
- IERC20.json
- USD.json

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%204.webp?raw=true)

Finally, let’s launch the front end using:

```solidity
npm start
```

## The Payback

Let’s test out all the functionalities we have imbued into our dApp. We’ll start with staking some BTC because our App repurposes the staked BTC for lending out BTC to users in need.

### Stake ‘em: Start Lending BTC

Follow these steps to start lending BTC:

- Click on the Connect Wallet button to connect your wallet.
- Use the faucet to get 100 USD and 10 BTC tokens.
- Click on the Start Lending button to navigate to the lending page.
- Enter the amount of BTC you want to stake (up to 10 BTC).
- Click the Stake button.
- Approve the transaction in the MetaMask popup that appears.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%205.webp?raw=true)

### Borrow ‘em: Borrow BTC Using USD Collateral

Use your staked BTC to provide funds for users who want to borrow BTC by using USD as collateral. Follow the steps below:

- Click on the 'Borrowing' link in the navigation bar to access the Borrow page.
- Enter the amount of USD you wish to deposit as collateral.
- Click the *Stake* button.
- Approve the transaction in the MetaMask popup that appears.
- Enter the amount of BTC you want to borrow.
- Click the *Borrow BTC* button.
- Approve the transaction in the MetaMask popup that appears.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%206.webp?raw=true)

### Repay ‘em: Repay Borrowed BTC and Withdraw Collateral

Repay the borrowed BTC with interest and then withdraw your deposited collateral. Follow these steps:

- Click on the *Repay loan* button.
- Approve the transaction in the MetaMask popup that appears.
- Enter the amount of collateral you wish to withdraw in the *Stake and Withdraw Collateral* section.
- Click the *Withdraw* button.
- Approve the transaction in the MetaMask popup that appears.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L12%20Image%207.webp?raw=true)

And there we have it, all the functionalities of our Lending dApp and works well as intended.

## Pushing It to Git

Make sure you are in `build-lending-dapp-on-core` folder.

As always, remember to push your code to your GitHub repository using the following commands.

```solidity
git add .
git commit -m "code update"
git push origin HEAD:refs/heads/Branch4
```

## Wrap Up

Hey y’all! We’ve reached the Endgame! We’ve successfully assembled the core functionalities of our lending dApp. From staking BTC and borrowing with USD collateral to repaying loans and withdrawing collateral, we’ve ensured everything works seamlessly. Our dApp is now complete and ready to rock. Great job 🎉


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/4.%20Interface%20and%20ERC20%20standard/4.%20Implement%20functions%20for%20Calculating%20interest%20and%20loan%20repayment.md

Implement Functions for Calculating Interest and Loan Repayment

# Writing Secure Smart Contracts

Welcome back, buddy! We love how you are being so great and awesome in this journey so far. So we have completed building our dApp. Well, now we have more things to explore.

Imagine building a fancy vending machine for the digital age, filled with cool stuff you can buy with crypto. That's kind of what a smart contract is – a program on the blockchain that automates agreements and transactions. Pretty neat, right? But just like any machine, if it's not built securely, someone might find a way to exploit it and steal your crypto snacks!

This lesson is your guide to building **bulletproof smart contracts**. We'll explore the sneaky tricks hackers love (and how to avoid them), as well as best practices to make your contract a fortress.

## Common Vulnerabilities in Smart Contracts

### 1. Reentrancy Attacks

Imagine you’re a cashier at a store. A customer gives you money for an item, and before you finish updating your register, the customer keeps requesting more items using the same initial payment. You end up losing inventory because the register wasn't updated in time.

This kind of flaw was exploited in the [famous DAO attack](https://liquidity-provider.com/articles/what-was-the-dao-the-story-of-infamous-hack/#:~:text=The%20DAO's%20success%20was%20short,funds%20and%20prevent%20future%20attacks), where attackers repeatedly called the withdrawal function before the balance was updated.

**Solution**: Always update the state before making external calls. Use the Checks-Effects-Interactions pattern to avoid reentrancy issues.

```solidity
// Checks-Effects-Interactions pattern
function withdraw(uint _amount) public {
	require(balances[msg.sender] >= _amount);
	
	// Effects
	balances[msg.sender] -= _amount;

	// Interactions
	(bool success, ) = msg.sender.call{value: _amount}("");
	require(success, "Transfer failed.");

}
```

We followed this strategy in our functions by placing the require statements and making changes.

### 2. Integer Overflow and Underflow

Picture an odometer in a car. If it only has five digits, once it hits 99,999, the next mile rolls it over to 0. Similarly, numbers in computers can "wrap around" if not handled correctly.

**Solution**: Use SafeMath libraries that handle these issues, or better yet, rely on Solidity's built-in overflow checks in version 0.8.0 and above.

```solidity
// Using SafeMath for safe arithmetic
using SafeMath for uint256;
uint256 public totalSupply;

function addSupply(uint256 _amount) public {
	totalSupply = totalSupply.add(_amount); // Safe addition
}
```

### 3. Unchecked Call Return Values

Imagine sending an email to a friend and assuming they received it without checking their reply. They might not have received it at all!

**Solution**: Always check the return value of low-level calls to ensure they succeed.

```solidity
(bool success, ) = someAddress.call{value: msg.value}("");
require(success, "Call failed.");
```

### 4. Front-Running

Think of placing a bid at an auction, but someone sees your bid and quickly places a higher bid before yours is processed. This is akin to front-running in blockchain transactions.

**Solution**: Design your contracts to be resistant to front-running by using commit-reveal schemes or by batching transactions in a way that prevents individual transactions from being prioritized unfairly.

```solidity
// Commit-reveal scheme
mapping(address => bytes32) public commitments;

function commit(bytes32 _commitment) public {
	commitments[msg.sender] = _commitment;
}

function reveal(uint256 _value, bytes32 _salt) public {
	require(commitments[msg.sender] == keccak256(abi.encodePacked(_value, _salt)));
	// Process the revealed value

}
```

## Best Practices for Secure Smart Contract Development

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L13%20Image%201.webp?raw=true)

1. **Code Reviews and Audits**
Think of it like getting a second opinion from a doctor. Another set of eyes can catch things you might have missed.
So it’s better if you regularly have your code reviewed by peers and conduct thorough audits before deploying to the mainnet.
2. **Use of Established Frameworks (e.g., OpenZeppelin)**
Building a house with pre-approved blueprints and materials ensures safety and reliability.
Similarly, you should utilize established libraries like [OpenZeppelin](https://www.openzeppelin.com/), which are widely used and tested in the community. Remember, we used imports from OpenZeppelin too:
    
    ```solidity
    import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
    import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
    import "@openzeppelin/contracts/access/Ownable.sol";
    ```
    
3. **Formal Verification and Testing**
It’s like stress-testing a bridge before allowing traffic. You want to make sure it holds up under various conditions.
You should use formal verification tools and write comprehensive tests to simulate different scenarios and edge cases.

## Tools and Techniques

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L13%20Image%202.webp?raw=true)

1. **Static Analysis Tools (e.g., [MythX](https://mythx.io/), [Slither](https://github.com/crytic/slither))**
These tools are like spell checkers for your code, automatically finding errors and vulnerabilities. You should regularly run static analysis tools on your smart contracts to catch potential issues early.
2. **Dynamic Analysis and Fuzzing**
Imagine testing a car by driving it over all kinds of terrain to see how it performs under different conditions.
Just like that, you should use dynamic analysis and fuzzing to test how your contract behaves under various inputs and states.
3. **Auditing Tools and Services**
Think of it as hiring a security expert to test the locks on your doors and windows.
So engage with professional auditing services to get an in-depth security assessment of your smart contracts.

## Wrap Up

Writing secure smart contracts is crucial for maintaining the integrity and trust of blockchain applications. By understanding common vulnerabilities and following best practices, you can create contracts that are robust and secure. Always use established tools and frameworks, conduct thorough testing, and seek external audits to ensure your smart contracts stand up to scrutiny. Happy coding, and stay secure!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/4.%20Interface%20and%20ERC20%20standard/5.%20Writing%20Secure%20Smart%20Contracts.md

Writing Secure Smart Contracts

# Wrap 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. Let's summarize what you've learned and how it can empower you in the world of blockchain development.

## What You Built

A Lending dApp on the Core blockchain. It had the following key features:

- **Staked USD to Borrow BTC**: You built the functionality of depositing **USD tokens** as collateral to borrow **BTC** tokens. It's like putting down a deposit to access funds within the Core DeFi ecosystem.
- **Collateralized Loans**: You maintained a minimum collateralization ratio, like staking 1.5 USD to borrow 1 BTC.
- **Flexible Borrowing and Lending**: You built the staking and lending functionality. Where in staking, the learners can stake USD to receive BTC tokens and repaid with interest within a set timeframe. Or can lend BTC directly to borrowers and earn interest.
- **USD Deposits and Withdrawals**: You learned how to manage the USD deposits and withdrawals based on lending or borrowing needs.
- **BTC Repayment**: You built how to repay borrowed BTC tokens with interest to unlock the staked USD collateral.

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C2%20assets%20-%20Start%20Building%20on%20Core/Core%20C2%20L14%20Image%201.webp?raw=true)

## What We Covered

We covered the following:

- **Introduction:** Got an overview of Core, the bitcoin-centric advantage, Core Blockchain programs, Solidity, and created a Metamask wallet.
- **Getting Started with Development:** Learned how to set up your development environment and installed the necessary tools.
- **Building Your Lending dApp Project:** We built the dApp and covered the Solidity basics, created structure, and studied mapping, functions, Interface, ERC20, constructors, and operators. We implemented functions to stake, borrow, and calculate interests.
- **Deploy and Interact:** We also learned how to deploy your dApp to the Core blockchain testnet and interact with it side by side.

## ⚒️ A small Yet Important Request

Here’s a great news for you! 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). If you find any issues in the course, please feel free to resolve them. 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](https://github.com/0xmetaschool/Learning-Projects). 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/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn) as well. 🫶
3. Subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos.

Also, now that you have a strong understanding of Core, Why don't you take the next step and become an active participant in the Core ecosystem? Here's how you can get involved and make your mark:

1. Join their [Telegram channel](https://t.me/CoreDAOTelegram), [Discord channel](https://discord.com/invite/coredaoofficial).
2. Follow Core Chain on [X](https://twitter.com/Coredao_Org), [X account for Devs](https://x.com/corechain_devs), and subscribe on the [YouTube](https://www.youtube.com/@Core_DAO_Official) channel.
3. Contribute directly to the CoreDAO [Github Repository](https://github.com/coredao-org).

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the in-depth knowledge to start building in the exciting world of Core blockchain. We wish you luck!

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Core/5.%20Conclusion/1.%20Wrap%20up.md

Start Building on Core

Dive into the world of NFTs and create your 10,000-piece NFT collection on the Core blockchain! This course guides you through everything from understanding NFTs and tokenomics to building, deploying, and interacting with your ERC721 smart contract. Learn how to structure your project, create unique artwork, and integrate a front-end for user interaction. Get ready to launch your own NFT collection with confidence!

# What are we building today?

Hey Core Crusaders! Ready to level up your NFT game? If you've already crushed the [first two Core blockchain courses](https://metaschool.so/coredao), you know all about this blockchain – Bitcoin's security, EVM's flexibility, and a community that's buzzing with creativity!

Pro tip: Staying connected with blockchain projects through their official GitHub repos can lead to unexpected perks. Many chains reward active community members with airdrops and other incentives. Make sure to follow [Core's repo](github.com/coredao-org) to stay in the loop!

But guess what? We're not stopping there. We're diving headfirst into the wild world of NFTs, and you're coming with us! In this course, we're going to turn you into an NFT ninja, capable of creating a mind-blowing collection of 10,000 unique digital treasures.

![it.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%201%20What%20are%20we%20building%20today/it.gif?raw=true)

Think of it like this: if the first two courses were your training montage, this is where you step into the ring and become a champion.  We're talking about mastering the art of generating thousands of one-of-a-kind NFTs, wielding the power of Solidity like a pro, and joining a community of fellow NFT enthusiasts who are just as passionate as you are.

And just to give you an idea of how vibrant the Core ecosystem already is, at the time off writing there are already over [80+ dApps](https://coredao.org/explore/ecosystem) supported and [265M+ transactions on-chain](https://scan.coredao.org/). By diving into this course, you'll not only develop in-demand skills, but also position yourself at the forefront of this exciting blockchain.

So, are you ready to unleash your inner NFT artist and show the world what you're made of? Let's mint some magic on Core blockchain! 

<a href="https://www.youtube.com/watch?v=pfgEkSLhNLw" target="_blank">
<img src="https://github.com/user-attachments/assets/b0da7fee-e7ce-4c28-9e3e-ae0900934ea8" alt="Watch the video" />
</a>

### Why This NFT Adventure?

NFTs aren't just digital collectibles; they're a revolution in ownership, art, and community. By building your own 10K NFT collection on Core blockchain, you'll:

- **Become an NFT Maestro:** Learn the ins and outs of generating thousands of unique digital assets, each with its own special flair.
- **Speak Solidity Like a Pro:** Master the language of smart contracts and make your NFTs come alive on the blockchain.
- **Join the NFT Elite:** Connect with a vibrant community of artists, developers, and collectors who are shaping the future of digital ownership.
- **Show Off Your Skills:** Earn a badass NFT badge that proves you're a certified Core NFT creator.

## Course Overview

We will:

1. Learn all about NFTs
2. Setting up Core blockchain development environment
3. Learn how to develop ERC721 smart contracts
4. Learn how to build and deploy an NFT application using Solidity

## Who exactly should take this course?

This course is for beginner to intermediate Web3 developers who wish to learn about Core blockchain and have completed our introductory courses on the Core blockchain. You should have basic programming knowledge as it will help you have a quick start to this course but if not, we are here for you!

## What will you be getting out of this course?

You will be getting the following outcomes when you complete this course:

1. Get a good understanding of NFT development on Core blockchain
2. Get yourself ready for the next course in the series
3. Claim your NFT on course completion

## Proof of completion

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

![Core C3 NFT (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%201%20What%20are%20we%20building%20today/Core_C3_NFT_(1).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 [Github](https://github.com/0xmetaschool/), it would be a great support. 🫣
4. Stay happy and positive!

All right, everyone, there is no need to wait any longer. Let’s get started!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20are%20we%20building%20today.md

# Introduction to NFT

Alright, NFT adventurers, buckle up! We're about to blast off into the heart of the NFT universe.🚀 Today, we're ditching the training wheels and diving headfirst into the heart of what makes NFTs tick. Think of this lesson as your backstage pass to the NFT concert – we'll uncover their history, their superpowers, and why everyone from artists to investors is going gaga over them. 🎸

![nft.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%202%20Introduction%20to%20NFT/nft.png?raw=true)

# NFTs: More Than Just Fancy JPEGs

Let's rewind for a second and revisit the basics. NFT stands for non-fungible token, and it's basically a digital asset that's one-of-a-kind. Think of it like your favorite childhood toy, a rare baseball card, or even that embarrassing selfie you took back in high school (hey, it's still unique!).

![toys.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%202%20Introduction%20to%20NFT/toys.gif?raw=true)

These are all *non-fungible* things – they're unique, one-of-a-kind, and can't be replaced with something else, even if it looks the same.

Now, picture taking that uniqueness and turning it into a digital collectible. That's where the "token" part comes in. It's like a digital certificate of ownership, stored securely on a blockchain (you know, our trusty friend Core!). This certificate is like a digital fingerprint, proving that you own the original and that no one can copy or counterfeit it. Think of it as a digital trophy that you can show off to your friends and family, and maybe even sell for a profit!

# The Evolution of NFTs: A Digital Revolution

While NFTs might seem like a recent phenomenon their history goes back further than you might think.

Our time machine first takes us back to 2014, where a humble NFT called "Quantum" was minted on the Namecoin blockchain. It might not have been the Mona Lisa of NFTs, but it was a groundbreaking moment, marking the birth of a new era of digital ownership.

![first.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%202%20Introduction%20to%20NFT/first.png?raw=true)

Fast forward to 2017, and things started to heat up with the arrival of CryptoKitties on Ethereum. These adorable, pixelated cats took the internet by storm, with people spending millions of dollars to collect, breed, and trade them. CryptoKitties proved that NFTs could be more than just pretty pictures – they could be fun, interactive, and surprisingly valuable.

![cats.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%202%20Introduction%20to%20NFT/cats.png?raw=true)

But the real NFT frenzy didn't kick off until 2021. Digital art, music, sports memorabilia, virtual real estate – everything under the digital sun was being turned into an NFT. Beeple's digital collage sold for a mind-boggling $69 million at Christie's auction house, sending shockwaves through the art world and propelling NFTs into the global spotlight.

# NFTs Today: Unleashing Creativity and Rewriting the Rules

Fast forward to today, and NFTs are everywhere you look. They're not just about art anymore – they're revolutionizing industries and changing the way we think about ownership, creativity, and community.

- **Gaming:** Have you ever dreamed of owning a one-of-a-kind in-game sword, a unique skin that sets your character apart, or even an entire virtual world that's all yours?  NFTs are making that a reality.
- **Collectables:** Digital trading cards, virtual sneakers, and even tweets are being turned into valuable NFTs.
- **Music:** Support your favorite artists directly by buying their music as NFTs, get exclusive access to concerts and behind-the-scenes content, and even own a piece of the royalties.
- **Real Estate:** The metaverse is booming, and NFTs are your ticket to owning virtual land, building your dream home, and creating experiences that would be impossible in the physical world.
- **Identity and Credentials:** From diplomas to medical records, NFTs are being used to create secure, tamper-proof digital records that you can own and control.

![props.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%202%20Introduction%20to%20NFT/props.gif?raw=true)

# Fungible vs. Non-Fungible: Cracking the Token Code

Before we wrap things up, let's dive into the technical side of things. On the blockchain, tokens come in two flavors: fungible and non-fungible.

Fungible tokens are like the everyday currency you use. Think of dollars, euros, or even bitcoins. Each unit is interchangeable – one dollar is exactly the same as any other dollar, and you can easily trade one for another without losing any value. Fungible tokens are great for transactions, storing value, and making payments.

Non-fungible tokens, on the other hand, are the unique snowflakes of the token world. Each NFT has its own distinct identity and value, just like a rare collectible or a piece of art. You can't simply swap one NFT for another, because each one is special and irreplaceable. This uniqueness is what makes NFTs so valuable and sought-after in the digital realm.

# That's a wrap

And that's a wrap on our whirlwind tour of the NFT universe! We've covered a lot of ground today, from pixelated cats to multi-million dollar artworks. But this is just the beginning of your NFT adventure.

In our next lesson, we'll dive deep into the fascinating world of tokenomics and explore the different ways that creators, collectors, and investors are making money from NFTs. Get ready to discover how supply and demand, rarity, and utility all play a role in the value of these digital assets. It's time to unleash your inner economist and uncover the secrets of the NFT economy!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/1.%20Let%E2%80%99s%20Get%20Started/2.%20Introduction%20to%20NFT.md

Introduction to NFT

# Understanding Tokenomics

Welcome back, NFT pioneers! By now, you're practically fluent in NFT lingo, slinging around terms like "non-fungible" and "blockchain" like seasoned pros. But before we get our hands dirty minting our own digital masterpieces, we need to dive into the nitty-gritty of NFT economics, also known as "tokenomics." 

![bird.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%203%20Understanding%20Tokenomics/bird.png?raw=true)

Don't worry, we won't bore you with dry lectures and complicated formulas. Think of this lesson as a treasure map to unlock the secrets of NFT value. We'll explore the factors that influence how much your digital treasures are worth, so you can create NFTs that not only look cool but also have the potential to rake in some serious dough! 

## Tokenomics 101: The Economics of the NFT World

Let's start with the basics. Tokenomics is the study of the economic factors that affect the creation, distribution, and value of tokens. It's like the economics of the real world, but with a digital twist.

In the NFT world, tokenomics is all about understanding how supply and demand, utility, and other factors influence the price and value of your digital collectibles. Just as traditional economics deals with the production, distribution, and consumption of goods and services, tokenomics deals with the creation, distribution, and utility of tokens within a particular blockchain ecosystem.

### Why Tokenomics Matters

![y.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%203%20Understanding%20Tokenomics/y.gif?raw=true)

Tokenomics isn't just some abstract concept for economists to ponder over. It's a crucial element of any successful NFT project. Why? Because it directly impacts the value and longevity of your NFTs.

Think of it like building a house. You wouldn't just start stacking bricks without a blueprint, right? Similarly, you wouldn't launch an NFT project without a solid tokenomics strategy. A well-designed tokenomics model can incentivize participation, drive demand, and create a thriving ecosystem around your NFTs. It's like laying the foundation for a successful and sustainable community.

### Factors Influencing NFT Value: The Secret Sauce

So, what exactly goes into the NFT value recipe? Let's take a closer look at some of the key ingredients:

#### **Rarity**

Just like in the real world, scarcity drives up demand. The rarer your NFT, the more people will want it, and the more valuable it becomes. Think of it like that limited edition sneaker or that vintage comic book – the fewer there are, the more people are willing to pay for it. In the NFT world, rarity can be created through limited editions, unique attributes, or even through mechanisms like burning (permanently removing a certain number of tokens from circulation).

#### **Utility**

NFTs aren't just pretty pictures. Many of them come with additional perks, like access to exclusive events, communities, or even real-world benefits. The more useful an NFT is, the higher its perceived value. For example, an NFT that gives you access to a private Discord server with your favorite artist would likely be more valuable than one that doesn't offer any additional benefits.

#### **Community**

A strong and engaged community can make or break an NFT project. The more people who are excited about your NFTs, the more likely they are to hold onto them, trade them, and even evangelize them to others. A vibrant community can drive up demand and create a sense of scarcity, both of which can boost the value of your NFTs. Think of it like a fan club for your favorite band – the more passionate the fans, the more valuable the band's merchandise becomes.

#### **Reputation and Credibility**

The reputation of the artist, creator, or brand behind an NFT plays a huge role in its value. A well-known artist or a reputable brand will likely command higher prices for their NFTs, as their name adds credibility and desirability to the asset. It's like buying a painting from a famous artist – you're not just paying for the artwork itself, but also for the artist's reputation and the prestige associated with their name.

#### **Market Trends**

The NFT market is constantly evolving, with new trends emerging all the time. Staying on top of these trends can help you identify which NFTs are likely to increase in value. For example, if a particular type of NFT (like generative art or music NFTs) is gaining popularity, it could be a good time to invest in those types of assets.

![features.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%203%20Understanding%20Tokenomics/features.gif?raw=true)

## Mastering Tokenomics: Your Key to NFT Success

Understanding tokenomics isn't just about making money – it's about creating sustainable and successful NFT projects. By carefully designing the tokenomics of your NFT collection, you can:

- **Incentivize Participation:** Reward your community members for their engagement and support, creating a loyal fan base. This could be through airdrops (giving away free NFTs), exclusive content, or even governance rights (allowing NFT holders to vote on decisions related to the project).
- **Drive Demand:** Create a sense of scarcity and encourage trading activity, increasing the value of your NFTs over time. This could be achieved through limited editions, auctions, or even gamification elements that incentivize collecting and trading.
- **Build a Thriving Ecosystem:** Develop a self-sustaining economy around your NFTs, ensuring their long-term success. This could involve creating a marketplace for trading NFTs, offering staking rewards for holding NFTs, or even developing a virtual world where NFTs can be used as in-game assets.

## That's a Wrap: Get Ready to Mint Your Own NFT Empire!

By now, you should have a solid grasp of what tokenomics is and why it matters in the NFT world. Armed with this knowledge, you're ready to take the next step and start minting your own NFT masterpieces. But before you do, remember this: tokenomics is a complex and ever-changing field, so don't be afraid to experiment, learn from your mistakes, and constantly refine your strategy.

In the next lesson, we'll dive into the technical side of things and explore how different NFT standards work under the hood, including ERC-721 and ERC-721A. We'll compare their features and discuss the pros and cons of each. Get ready to learn the secrets of creating efficient, scalable, and user-friendly NFT collections on the Core blockchain!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/1.%20Let%E2%80%99s%20Get%20Started/3.%20Understanding%20Tokenomics.md

Understanding Tokenomics

# Introduction to NFT Collectibles

Alright, NFT trailblazers! Ready to level up your NFT game? Buckle up, because we're about to go beyond the basics and explore the beating heart of NFT creation: the ERC-721 token standard. This is the foundation that makes unique, one-of-a-kind digital treasures possible on the blockchain.

![nft.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%204%20Introduction%20to%20NFT%20Collectibles/nft.gif?raw=true)

We've talked about individual NFTs, but what about when you want to create a whole gang of them? That's where NFT collections come in. Think of them like a set of trading cards, a series of digital artworks, or a team of unique characters in a game. These collections often share a common theme, style, or story, and they're usually released in limited quantities to make them even more special.

Now, here's the kicker: creating a massive NFT collection, like the 10K masterpiece we're aiming for, isn't as simple as copy-pasting the same NFT a thousand times. That would be boring, right? 

![copiers.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%204%20Introduction%20to%20NFT%20Collectibles/copiers.gif?raw=true)

We need a way to create a bunch of NFTs that are similar but still unique, each with its own special flair. And that's where token standards like ERC-721  come in.

### The Anatomy of an NFT: Image and Blockchain Record

Every NFT has two main components:

- **The Image:** This is the visual representation of your NFT, whether it's a stunning piece of digital art, a pixelated character, or a 3D model of a virtual world.
- **The Blockchain Record:** This is the unchangeable proof of ownership and authenticity for your NFT. It's stored on the blockchain (in this case, the Core blockchain) and includes a unique identifier, the owner's address, and a link to the image file. Think of it like a digital certificate of authenticity that can never be altered or faked.

![nft-block.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%204%20Introduction%20to%20NFT%20Collectibles/nft-block.gif?raw=true)

## ERC-721: The OG Standard for Unique Digital Assets

The ERC-721 standard is the gold standard for creating NFT collections. It's a set of rules that defines how NFTs are created, managed, and transferred on the blockchain.

Here's why ERC-721 is the foundation of the NFT world:

- **Unique Identifiers:** Each NFT created using ERC-721 has a unique identifier, making it one-of-a-kind and distinguishable from any other NFT.
- **Ownership Tracking:** The blockchain permanently records who owns each NFT, ensuring clear ownership and easy, secure transfers.
- **Smart Contract Power:** ERC-721 NFTs are powered by smart contracts, which are self-executing pieces of code that can add exciting features like royalties for creators, unlockable content, or even the ability for your NFT to evolve over time.

## Why ERC-721 Remains the Top Choice

While other standards exist, ERC-721 continues to be the most popular choice for NFT collections due to its:

- **Established Reputation:** It's widely supported across the NFT ecosystem, including marketplaces, wallets, and development tools.
- **Flexibility:** ERC-721 can handle a vast range of NFT types, from art and collectibles to gaming assets and virtual land.
- **Community and Resources:** There's a thriving community of developers and a wealth of resources available to help you build with ERC-721.

## Your 10K NFT Collection Roadmap

![dbz.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%204%20Introduction%20to%20NFT%20Collectibles/dbz.gif?raw=true)

Here's a simplified roadmap for creating your 10,000 NFT collection using the ERC-721 standard:

1. **Conceptualization and Design:** Brainstorm your collection's theme, characters, or objects. Create a visual style guide.
2. **Artwork Creation:** Bring your ideas to life with stunning digital art.
3. **Metadata Generation:** Create detailed descriptions and attributes for each NFT.
4. **Smart Contract Development:** Write the Solidity code that governs your collection's rules and interactions.
5. **Minting and Deployment:** Launch your collection onto the Core blockchain.
6. **NFT Gallery Creation:** Build a website where collectors can browse, admire, and purchase your NFTs.

## Gearing Up: Setting Up Your Development Playground

In the next lesson, we'll set up our development environment, install the necessary tools, and configure our connection to the Core network. We'll be using Hardhat, a powerful smart contract development environment, to streamline the process and make our lives easier. Get ready to roll up your sleeves and dive into the world of Solidity and smart contract development! 💻

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/2.%20Building%20the%2010k%20NFT%20Collection/4.%20Introduction%20to%20NFT%20Collectibles.md

Introduction to NFT Collectibles

# Setting up the project structure

Hello, future NFT moguls! 🚀 Get ready to trade in your paintbrushes and sketchpads for lines of code and smart contracts, because today, we're building the ultimate digital workshop for your NFT creations! No more daydreaming about those unique collectibles – it's time to make them a reality on the blockchain.

In this lesson, we'll gather all the tools you need to mint, manage, and showcase your 10K NFT collection like a pro. We'll cover everything from installing essential software to setting up your project structure.  So grab your metaphorical hard hat, and let's get this NFT party started!

## Tool Time: Gathering Your Gear

Before we dive into the coding fun, we need to gather some essential tools. Think of it like prepping your ingredients before baking a cake – you can't make deliciousness without the right stuff!

![Frame 3560408.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%205%20Setting%20up%20the%20project%20structure/Frame_3560408.jpg?raw=true)

1. **Node.js & npm (or yarn):** Head over to [nodejs.org](https://nodejs.org/) and grab the installer for your operating system (Windows, macOS, or Linux). 
2. **Visual Studio Code (VSCode):** Grab it from [code.visualstudio.com](https://code.visualstudio.com/) and follow the simple installation instructions.
3. **Git:** Grab it from the official website: [git-scm.com](https://git-scm.com/) and follow the instructions.
4. **Git CLI:** It allows to connect with git via the terminal, so let’s install it too. You can follow the steps given [here](https://github.com/cli/cli). Once you have installed the Git CLI, let me tell you how you can configure your terminal with it.
    1. Open your terminal.
    2. Run `gh --version` to ensure that you have installed the Git CLI successfully.
    3. Run `gh auth login --web` in your terminal and follow the steps given below:
        1. First, it will ask for your preferred protocol for Git operations. I chose HTTPS, you can choose any.
        2. Second, it will ask you to Authenticate Git with your GitHub credentials, and type `Y`.
        3. Third, you will be able to see a code on your terminal. Copy it.
        4. Then, press Enter. It will open a window in your browser.
        5. Paste the code you copied and authorize your git. You might need to enter your GitHub password if you have yet to log in.
        6. Do not close this terminal!
    
    ![Screen Recording 2024-07-15 at 11.44.49 AM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%205%20Setting%20up%20the%20project%20structure/Screen_Recording_2024-07-15_at_11.44.49_AM.gif?raw=true)
    

Awesome, you are all set!! Good job!

### MetaMask

You can download MetaMask from [here](https://metamask.io/).

This handy browser extension is your gateway to the blockchain world. It acts as your crypto wallet, allowing you to securely store and manage your NFTs. You'll also use it to interact with decentralized applications (dApps) and connect to the blockchain of your choice.

Extract your public address and private key from the MetaMask Chrome extension as we will need them later on, follow these steps:

- Open the MetaMask extension in your browser.
- Click on the three dots in the upper right corner of your account card.
- Select "Account details" from the dropdown menu.
- You'll see your **public address** displayed at the top. Copy it for later use.
- To export your **private key**, click on "Show private key."
- Enter your MetaMask password to confirm.
- Click and hold the button to reveal your private key.
- Copy your private key and store it securely. Remember, never share your private key with anyone.

![address.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%205%20Setting%20up%20the%20project%20structure/address.gif?raw=true)

**We suggest keeping these pieces of information handy as we'll need them.** 

## Adding the Core Testnet to MetaMask: Your Blockchain Playground

Imagine the Core testnet as your personal blockchain playground. You can experiment, test your dApps, and make mistakes without worrying about real-world consequences.

Let’s add it to MetaMask so you can access it:

1. **Open MetaMask:** Click on the little fox icon in your browser (or open the app).
2. **Network Dropdown:** Click the dropdown menu at the top where it usually says "Ethereum Mainnet."
3. **Custom RPC:** Scroll down and select "Add network".
4. This will open a tab in the browser, click on “Add network manually” there.
5. **Enter Details:** Fill in the following information, double-checking that it's correct:
    - **Network Name:** Core Testnet
    - **New RPC URL:** [https://rpc.test.btcs.network](https://rpc.test.btcs.network/)
    - **ChainID:** 1115
    - **Symbol:** CORE
6. **Save:** Hit "Save," and you're in! It will ask you to switch to the network, well switch!

![image (11)](https://github.com/user-attachments/assets/920027b5-8ca5-4efe-98fd-be6766afe6a1)


You can explore more Core Blockchain RPC links [here](https://docs.coredao.org/docs/Dev-Guide/rpc-list).

### Fetching Some Test tokens

Well, we know that we need test tokens to run any transaction on the blockchain, so let’s fetch some.

1. Head over to Core testnet faucet: [https://scan.test.btcs.network/faucet](https://scan.test.btcs.network/faucet).
2. Enter your wallet address which is the same public address we had copied up in the previous lesson.
3. Click on “Get tCORE”.
4. View your Metamask, you might have received 1 CORE.
![image (9)](https://github.com/user-attachments/assets/c037bce3-5a79-4e3b-a534-5b3331cfb62f)


## That’s a Wrap

With your toolbox overflowing with awesome tools, you're ready to build your NFT workshop! In our next lesson, we'll create the framework for your project, organizing your code and assets into neat folders. We'll also show you how to connect your project to your preferred blockchain, so you can start minting NFTs like a pro. Get ready to flex those coding muscles and bring your NFT dreams to life! 🎨


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/2.%20Building%20the%2010k%20NFT%20Collection/5.%20Setting%20up%20the%20project%20structure.md

Setting up the Project Structure

# Creating a 10,000-Piece NFT Collection: A Guide for NFT Creators

Hey there, NFT creators! You've conquered the world of token standards and emerged victorious with the ERC-721 as your chosen weapon. Now, it's time to tap into your artistic genius and embark on the thrilling adventure of creating a massive 10,000-piece NFT collection. Let those creative juices flow, because we're about to turn your imagination into a digital goldmine!

![art.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%206%20Creating%20a%2010,000-Piece%20NFT%20Collection%20/art.gif?raw=true)

## Creating Your Digital Masterpieces: Images and Metadata

**Remember**, an NFT isn't just a pretty picture—it's a powerful fusion of art and technology. Each NFT is composed of two essential elements:

- **The Image**: This is the visual masterpiece that will captivate your audience and make your collection stand out. It's the artwork itself, whether it's a pixelated character bursting with personality, a meticulously hand-drawn illustration, a mind-bending 3D animation, or any other visual creation that you dream up. Think of it as the cover of your NFT's "book."
- **The Metadata**: This is where the magic happens—behind the scenes. Metadata is like your NFT's digital DNA, containing all the essential information that makes it unique and verifiable on the blockchain. This includes the NFT's name, a captivating description, a list of attributes that define its traits and rarity (think "laser eyes," "unicorn horn," or "legendary status"), and the all-important link to its image. It's like the table of contents and chapters of your NFT's story, revealing its hidden depths and making it verifiable on the blockchain.

## Generating Your 10K NFT Collection: Where Art Meets Automation

Now, let's get to the fun part – creating your massive collection of 10,000 unique NFTs! I know, 10,000 sounds like a lot (and it is!), but don't sweat it. We're going to harness the power of automation to make it a breeze. We'll use a handy image generator script that will do the heavy lifting for us, taking your base artwork and programmatically generating thousands of unique variations. It's like having an army of tiny digital artists working tirelessly to bring your vision to life!

### Step-by-Step Guide: Your NFT Assembly Line

#### **Installation**:

1. Make sure you have **Node.js** installed on your machine. It's the engine that will power our image generator script.
2. Clone the 10k NFT image generator project from GitHub:
    ```bash
     git clone https://github.com/0xmetaschool/10k-nft-image-generator.git
    ```
3. Navigate to the project directory:
    ```bash
     cd 10k-nft-image-generator
    ```
    

> **Attention Mac users!!!!**
Run the following commands in **BASH** shell to successfully complete the next steps as some modules cause trouble on Mac but not on other platforms:
> 

```
touch ~/.bash_profile
curl -o- [https://raw.githubusercontent.com/creationix/nvm/v0.33.1/install.sh](https://raw.githubusercontent.com/creationix/nvm/v0.33.1/install.sh) | bash
source ~/.nvm/nvm.sh
nvm --version
nvm install 16
nvm use 16
brew install python3
```

4. Next, open your terminal and run the following command to install all the necessary dependencies for the script:
    ```bash
     npm install
    ```
    
5. Finally, create an empty public GitHub repository (think of it as a digital gallery) and copy its HTTPS link. This is where we'll showcase your finished NFT collection. Paste the link into the `.env` file, next to the `GIT_REPO_URL` variable.
    
    ![git-repo.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%206%20Creating%20a%2010,000-Piece%20NFT%20Collection%20/git-repo.gif?raw=true)
    

---

## Generating Images and Metadata

With everything set up, let the magic begin! Run the image generator script with this command:

```bash
 node generate.js
```

Watch as the script works its magic, churning out 10,000 unique NFT images and their corresponding metadata files. The images will be neatly tucked away in a folder called `generated_images`, while their digital DNA (metadata) will be stored in a folder called `generated_metadata`.

```jsx
{
  "name": "Sarielle Keogh #2",
  "description": "Sarielle Keogh is a Dwarf Cleric, who has no sibling(s), and was born Among people of a different race and rasied by their extended Family. Sarielle Keogh lives in the lower Isle of Zarkus, where she lives out her days as a Peasant. Sarielle Keogh was taught smithing at a young age as she often worked and helped out at her local smithery.",
  "image": "https://<your-github-page>.io/<repository-name>/generated_images/2.png",
  "attributes": [
    {
      "trait_type": "Race",
      "value": "Dwarf"
    },
    {
      "trait_type": "Class",
      "value": "Cleric"
    },
    {
			.
			.
			.
			.
			.
			
  ]
}
```

---

Now, don’t get too confused with the image URI, since we are hosting the images on github pages, this is how the image URI format will look like!

> **Make sure to copy this URL `https://<your-github-page>.io/<repository-name>`. We will need it at the time of final compilation and deployment.**

Moving on!

## Uploading to GitHub

Time to share your creations with the world! Use this command to upload your freshly minted images and metadata to your GitHub repository:

```bash
 node upload.js
```

Your repository will now be a treasure trove of NFT goodness, ready to be discovered by eager collectors.

---

## Publishing Your Collection

1. Head over to your GitHub repository's settings and click on the "Pages" tab.
2. Choose "Deploy from a branch" and select the master branch.
3. Click "Save," and in a few minutes, your NFT collection will be live on a beautiful webpage powered by GitHub Pages!

![git-pages.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%206%20Creating%20a%2010,000-Piece%20NFT%20Collection%20/git-pages.gif?raw=true)

Now, if you go to `metadata` folder and open any JSON file. Copy the image URL and paste it new tab, you can view the image.

![Screen Recording 2024-07-24 at 6.12.11 PM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%206%20Creating%20a%2010,000-Piece%20NFT%20Collection%20/Screen_Recording_2024-07-24_at_6.12.11_PM.gif?raw=true)

## Next Steps: Bringing Your NFTs to Life on the Blockchain

With your 10K NFT collection generated and ready to showcase, we're now ready to dive into the world of smart contracts. In the next lesson, we'll learn how to write the code that will power your collection on the Core blockchain, using the ERC-721 standard. Get ready to transform your collection from a set of static images to a dynamic and interactive experience for collectors!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/2.%20Building%20the%2010k%20NFT%20Collection/6.%20Creating%20a%2010%2C000-Piece%20NFT%20Collection.md

Creating a 10,000-Piece NFT Collection: A Guide for NFT Creators

# Creating the ERC721 Smart Contract

Hello everyone! Welcome to another lesson! This one is going to be super interesting since we are going to create our very own smart contract to mint NFTs. Sounds fun, right? So, let’s get straight into it. 

![aptos-c4-l10 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%207%20Creating%20the%20ERC721%20Smart%20Contract/aptos-c4-l10_(1).gif?raw=true)

## Set Up Your Project

Hardhat is our secret weapon for smart contract development! It simplifies everything from testing your code to deploying it on the blockchain. You can think of it as your blockchain toolkit. Well, instead of building everything from scratch, we have made it easy for you by providing a boilerplate code. This will help you to start right away~

Run the following command in your terminal:

```
gh repo fork https://github.com/0xmetaschool/10k-nft-boilderplate.git --clone 
```

This will clone the boilerplate code of your project onto your system and fork the repository to your Git account as well.

Now run these commands:

```
cd 10k-nft-boilderplate/backend 
npm install
```

This will download and install Hardhat, its dependencies, and other code libraries like `ether.js` that it needs to work.

## Configuring Hardhat for Core

Now, let's tell Hardhat about our new playground (the Core testnet). This will allow it to connect to the network and deploy our contracts on the Core testnet.

Create a `.env` file in `10k-nft-boilderplate/backend` folder and add the following content to it.

```
PRIVATE_KEY=""
```

We copied our private key, well, here we will use it. Paste the private key into your `.env` file in between the `“”`. And we are set!

![Frame 3560410.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%205%20Setting%20up%20the%20project%20structure/address.gif?raw=true)

YOU ARE ALL SET!!!!

## Our Smart Contract

Navigate to `10k-nft-boilderplate/backend/contracts/NFT.sol`. We already have the code for you. Let’s understand it.

We will be using the ERC721 NFT smart contract from Openzeppelin. The contracts from  Openzeppelin are battle-tested which means, we do not have to worry much about the security of our smart contract as it is already taken care of. So let’s start building our smart contract:

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

- The SPDX license identifier is a way of specifying the license under which our contract's code is distributed. Here, `MIT` indicates that the code is licensed under the MIT License.
- The `pragma` directive is used to specify the version of the Solidity compiler that should be used to compile the contract.

```solidity
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
```

- The first three import statements import the `ERC721` , `ERC721Enumerable`, and `ERC721URIStorage` contracts from the OpenZeppelin library.
- The next import is ownable which will be used when the owner has to have special rights.
- The last import `Ownable` statement imports the `Strings` library from the OpenZeppelin library. 
The `Strings` library provides functions for string operations, such as converting numbers to their string representation.

```solidity
contract CoreNFT is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
```

- This line declares a new smart contract named `CoreNFT`.
- `is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable` specifies that `CoreNFT` contract inherits from the `ERC721`, `ERC721Enumerable`, `ERC721URIStorage`, `Ownable` meaning, we can use all the functions from these contracts in our contract.

```solidity
       using Strings for uint256;
       uint256 private _nextTokenId;
       string private _baseURIExtended;
```

- `using Strings for uint256`: Enables `uint256` variables to use functions from the `Strings` library for converting numbers to strings.
- `uint256 private _nextTokenId`: Declares a variable to track the number of NFTs minted so far.
- `string _baseTokenURIExtended`: Declares a variable to store the base URI for NFT metadata. This is where all your NFT metadata is stored.

```solidity
constructor(string memory baseURI_)
        ERC721("CoreNFT", "CORE")
        Ownable(msg.sender)
    {
        _baseURIExtended = baseURI_;
				_nextTokenId = 0;
    }
```

When you first deploy the contract, it runs a special function called the constructor. This function runs only once during the deployment of the smart contract. This constructor in our contract does two main things. 

- It gives your NFT collection a name, "CoreNFT," and a short symbol, "Core," by calling the parent `ERC721` contract. It also sets the owner of the contract to your address since you deploy the contract.
- Second, it sets up a base URL, called `_baseURIExtended`, where the metadata for your NFTs will be stored and initializes `_nextTokenId` to 0 as well.

```jsx
    function setBaseURI(string memory baseURI_) external onlyOwner {
        _baseURIExtended = baseURI_;
    }
```

- This function, `setBaseURI`, allows the contract owner to set a new base URI for the NFT metadata. The `onlyOwner` modifier ensures that only the contract owner can call this function. The `baseURI_` parameter is a string that specifies the new base URI, and it updates the `_baseURIExtended` variable in the contract.

```solidity
    function safeMint(address to) public onlyOwner {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, string(abi.encodePacked(Strings.toString(tokenId), ".json")));
    }
```

- `uint256 tokenId = _nextTokenId++` increases the token ID and assigns it to `tokenId` so that you can go ahead and proceed to mint further
- The `_safeMint(msg.sender, tokenId);`  sends the NFT with the earlier set `tokenId` to `msg.sender` which is your address in this case.
- Finally, `_setTokenURI(tokenId, string(abi.encodePacked(Strings.toString(tokenId), ".json")))` sets the metadata URI for a specific NFT by converting the token ID to a string, and then adding `.json`, and storing this full string as the token's URI

```solidity
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseURIExtended;
    }
```

The function `_baseURI()` in this contract overrides the base implementation from the ERC721 contract. Can you guess what it returns? It returns `_baseURIExtended`, which is the custom base URL for our NFT metadata. This is how the contract knows where to find the starting point for all the token metadata URLs.

```solidity
function getCurrentTokenId() public view returns (uint256) {
        return _nextTokenId;
```

This function returns the current TokenId. This also represents the number of NFTs minted so far. 

Lastly, we have the following functions which have to be overridden as required by Solidity.

```solidity
    function _update(address to, uint256 tokenId, address auth)
        internal
        override(ERC721, ERC721Enumerable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }
    function _increaseBalance(address account, uint128 value)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }
    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString(), ".json")) : "";
    }
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
} 
```

## Complete code

Now that we are done, let’s see what the complete code looks like:

```jsx
// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
contract CoreNFT is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
       using Strings for uint256;
       uint256 private _nextTokenId;
       string private _baseURIExtended;
   constructor(string memory baseURI_) ERC721("CoreNFT", "CORE") Ownable(msg.sender) {
        _baseURIExtended = baseURI_;
        _nextTokenId = 0;
    }
    function setBaseURI(string memory baseURI_) external onlyOwner {
        _baseURIExtended = baseURI_;
    }
    function safeMint(address to) public onlyOwner {
        uint256 tokenId = _nextTokenId++;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, string(abi.encodePacked(Strings.toString(tokenId), ".json")));
    }
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseURIExtended;
    }
    function getCurrentTokenId() public view returns (uint256) {
        return _nextTokenId;
    }
    // The following functions have to be overridden as required by Solidity.
    function _update(address to, uint256 tokenId, address auth)
        internal
        override(ERC721, ERC721Enumerable)
        returns (address)
    {
        return super._update(to, tokenId, auth);
    }
    function _increaseBalance(address account, uint128 value)
        internal
        override(ERC721, ERC721Enumerable)
    {
        super._increaseBalance(account, value);
    }
    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString(), ".json")) : "";
    }
    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable, ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
} 
```

## Wrap up

Congratulations!! You have successfully understood your own NFT contract to mint NFT. Keep up the pace!  There is so much more to learn, but we are sure that you are going to have a lot of fun in the upcoming lessons while we deploy and interact with our contract! So, see you there!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/2.%20Building%20the%2010k%20NFT%20Collection/7.%20Creating%20the%20ERC721%20Smart%20Contract.md

Creating the ERC721 Smart Contract

# Compiling and Deploying Contract

Welcome back to another new lesson! Now that we are done with writing our smart contract, let’s deploy the NFT contract. Sounds interesting, right? Let’s get started!! 

## Compiling the contract

Make sure you are in `10k-nft-boilderplate/backend/` folder.

Let’s compile our contract using:

```jsx
npx hardhat compile
```

On successful compilation, you should see something like so: 

![core-c3-l8.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%208%20Compiling%20and%20Deploying%20Contract/core-c3-l8.jpg?raw=true)

## Deploying the Contract

Now finally, let’s deploy the contract on Core Testnet. Before deploying, make sure, you have added Core testnet to your Metamask wallet and have funded it with test tokens as mentioned in the previous lessons. 

Navigate to `backend/ignition/modules/NFT.js` and we have the deployment file there. It imports the `buildModule` function, creates an NFT module, fetches the `CoreNFT` contract, and exports it for use in the Hardhat project.

> **Remember I asked you to copy your image URL in the lesson `Creating a 10,000-Piece NFT Collection`. Using that info, replace `<your-github-page>` and `<repository-name>` with your info in the following code.
> Let me remind you where you can fetch the info. Just go to your image collection repo open any JSON file from your metadata folder and copy the URL.**
![core c5 (12)](https://github.com/user-attachments/assets/bb756d20-18d6-42ec-b98c-2065cef12b3f)


```jsx
const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules");

module.exports = buildModule("NFTModule", (m) => {

  const nft = m.contract("CoreNFT", ["https://<your-github-page>.io/<repository-name>/generated_metadata/"]);

  return { nft };
});
```

You can now deploy using:

```solidity
npx hardhat ignition deploy ./ignition/modules/NFT.js --network core_testnet
```

It will ask to confirm the deployment. Press `y`. Once, it's deployed, you will see something like below. Copy your deployed address.

![core-c3-l8 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%208%20Compiling%20and%20Deploying%20Contract/core-c3-l8_(1).jpg?raw=true)

## Checking Transaction on Block Explorer

We can use Core Scan to check our transactions. To do that, let’s go to [this](https://scan.test.btcs.network/) link.

Once you are there, paste the address you received in the previous step in the search bar. You can now see that you have made the transaction: 

![Screen Recording 2024-07-25 at 10.33.32 AM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%208%20Compiling%20and%20Deploying%20Contract/Screen_Recording_2024-07-25_at_10.33.32_AM.gif?raw=true)

## Verifying our Contract

To verify the contract, we first need to add our API Key from Core Scan to our `.env` file. Let’s see how we can do that:

- Go [here](https://scan.test.btcs.network/) and create your account
- Once your account is created, when you go to your profile, you will see an option API-KEYs.

  ![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%208%20Compiling%20and%20Deploying%20Contract/Untitled.png?raw=true)

- You can now click on `add` and create your API Key, we have named it `my_key`, but you can name it anything you want.

  ![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%208%20Compiling%20and%20Deploying%20Contract/Untitled%201.png?raw=true)

Once we have our key, let’s copy it and paste it into our `.env` file by assigning it to `API_KEY`

Our `.env` file now looks like this:

```jsx
PRIVATE_KEY = "YOUR_PRIVATE_KEY"
API_KEY="YOUR_API_KEY"
```

We are now finally ready to verify our contract! We need to follow just one last step to verify our contract. To do that, you can simply replace <CONTRACT ADDRESS> below with your deployed contract address you got during the last step: 

```jsx
npx hardhat verify --network core_testnet <CONTRACT ADDRESS> "https://corenft.vercel.app/generated_metadata/"
```

If the verification is done correctly, you should see something like this: 

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%208%20Compiling%20and%20Deploying%20Contract/Untitled%202.png?raw=true)

## Pushing it to Git

Make sure you are in `10k-nft-boilderplate/backend/` folder. Remember to push your code to your GitHub repository using the following commands. 

```solidity
git add .
git commit -m "code update"
git push
```

## Wrap Up

Congratulations!! You have achieved a lot in this lesson! From compiling the contract to deploying it and even verifying your contract. You have done it all! You have even checked your transaction on Core Scan. Well done! In the next lesson, we will interact with the frontend. See you there!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/3.%20Compile%2C%20Deploy%2C%20and%20Interact/8.%20Compiling%20and%20Deploying%20Contract.md

Compiling and Deploying Contract

# Front-end interaction

Hey there, NFT visionaries! 🚀 We've minted our 10K NFT collection and deployed our trusty ERC-721 smart contract to the Core testnet. Now, it's time to roll out the red carpet and showcase our digital masterpieces to the world! 

![reveal.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%209%20Front-end%20interaction/reveal.gif?raw=true)

In this lesson, we'll be building a sleek and stylish frontend gallery that allows users to browse, admire, and even purchase your NFTs. It's like curating your very own digital art exhibit but without the pretentious wine and cheese! 🍷🧀

## Navigating to Your Frontend Directory

Assuming you've been following the chapters with the precision of an artist, your project structure should look like this:

```arduino
10k-nft-boilderplate/
├── backend/           // Your smart contracts and deployment scripts
├── frontend/          // The React frontend we'll be working with
```

To start working on the frontend, navigate to the `frontend` directory using your terminal:

```bash
 cd frontend
```

This is where the magic of bringing your NFTs to life happens!

## Installing Dependencies: Powering Up Your Gallery

Just like a gallery needs lights, walls, and a security system, your frontend needs some essential software tools to run smoothly. Think of these dependencies as the building blocks of your gallery's infrastructure:

### Install Dependencies

Open your terminal (while still in the frontend directory) and run the following command:

```bash
 npm install
```

This will fetch and install all the necessary packages and libraries that your frontend project needs to function properly. Think of it as a shopping spree for your project, gathering all the right tools and materials to make it shine!

## Adding the Contract ABI: The Secret Decoder Ring

Now, let's give your frontend the ability to talk to your smart contract. You'll need to copy the `.json` files containing the ABI (Application Binary Interface) from the backend directory.

### Steps to Add the ABI:

1. **Locate ABI Files:** The ABI files are usually in the `backend/artifacts/contracts` folder. In this case, we need the `CoreNFT.json` file, which describes the structure and functions of your NFT smart contract.
2. **Copy and Paste:** Create a new folder, `ABI` inside `frontend/src`.  Copy the `CoreNFT.json` file and paste it into the `frontend/src/ABI/` folder. This will give your frontend the decoder ring it needs to understand and interact with your smart contract. Think of it as teaching your gallery how to speak the language of the blockchain!

![abi.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%209%20Front-end%20interaction/abi.gif?raw=true)

## Launching Your NFT Gallery: Opening Night!

With everything in place, it's time to unveil your digital art exhibit to the world!

### Start the Development Server

In your terminal (still in the frontend directory), run the following command:

```bash
 npm start
```

This will compile your frontend code and launch a local development server. You should see a new browser window or tab open automatically, displaying your NFT gallery.

### View Your Masterpieces

Marvel at your beautiful creation! Your frontend gallery should now be displaying your 10K NFT collection in all its glory. Just ***paste the deployed address of the NFT contract*** and you'll see the images of your NFTs, their names, descriptions, and any other metadata you've included. You can even interact with the smart contract to view ownership details or transfer NFTs.

![appl.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Core%20C3%2010k%20NFT%20Images/Lesson%209%20Front-end%20interaction/appl.gif?raw=true)

## Pushing it to Git

Make sure you are in `10k-nft-boilderplate` folder. Remember to push your code to your GitHub repository using the following commands. 

```solidity
git add .
git commit -m "code update"
git push
```

## Wrapping Up: Your NFT Journey Continues!

Congratulations! You've successfully built your very own NFT collection and launched a stunning frontend gallery to showcase it to the world. This is a major milestone, but the journey doesn't end here.

In our final lesson, we'll recap everything we've learned. So, stay tuned for one last adventure in the world of digital collectibles! 🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/3.%20Compile%2C%20Deploy%2C%20and%20Interact/9.%20Front-end%20interaction.md

Front-end interaction

# 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. Let's summarize what you've learned till now.

## Building the 10k NFT Collection

One of the most interesting parts of the course was that we built our very own 10K NFT collection! We used an image generator to generate NFT images from different layers. Not just that, we even created our very own smart contract to mint NFT.

## Deploy and Interact with Contract

Another super interesting part filled with learning, was when we deployed our NFT contract on Core and interacted with it through frontend. And that’s how we built a full-fledged project which not only creates a contract but also interacts with it through our frontend.  

You did great and we are so proud of you!
![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%2010%20Let%E2%80%99s%20Wrap%20It%20Up/aptos-c4-l10.gif?raw=true)

## ⚒️ A small yet important request

Here is great news for you! 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). If you find any issues in the course, please feel free to resolve them. 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](https://github.com/0xmetaschool/Learning-Projects). 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/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn) as well. 🫶
3. Subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos.

Also, now that you have a strong understanding of Core, Why don't you take the next step and become an active participant in the Core ecosystem? Here's how you can get involved and make your mark:

1. Join their [Telegram channel](https://t.me/CoreDAOTelegram), [Discord channel](https://discord.com/invite/coredaoofficial).
2. Follow Core Chain on [X](https://twitter.com/Coredao_Org), [X account for Devs](https://x.com/corechain_devs), and subscribe on the [YouTube](https://www.youtube.com/@Core_DAO_Official) channel.
3. Contribute directly to the CoreDAO [Github Repository](https://github.com/coredao-org).

Next, don’t forget to congratulate them on this achievement. Make them feel valuable.

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the in-depth knowledge to start building in the exciting world of Core. We wish you luck!

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Core%20C3%20Launching%20a%2010K%20NFT%20collection%20on%20Core/4.%20Wrap%20Up/10.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Let’s Wrap It Up

Launching a 10K NFT collection on Core

Gear up for an epic adventure in blockchain gaming with our Battle Royale Game course on the Core blockchain! This hands-on course will guide you through every step, from setting up your development environment to deploying your game as a dApp. You'll master Core development while creating an action-packed, interactive game, gaining valuable experience with Solidity programming, smart contracts, and the Core ecosystem. Learn to harness the power of constants, variables, structs, and functions to craft a dynamic gaming experience. Perfect for those eager to level up their skills in Core development and Solidity!

# What Are We Building Today

Calling all Core crusaders! 🚀 If you've conquered the first few courses in the Core learning track, you already know this blockchain is a force to be reckoned with. It's got Bitcoin's rock-solid security, Ethereum's developer-friendly flexibility, and a community that's bursting with creativity. But guess what? We're about to take your Core skills to a whole new level and turn you into NFT battle masters! 💪

Pro tip: Staying connected with blockchain projects through their official GitHub repos can lead to unexpected perks. Many chains reward active community members with airdrops and other incentives. Make sure to follow [Core's repo](github.com/coredao-org) to stay in the loop!

## Leveling Up Your NFT Game: From Collectibles to Champions

Imagine this: Your 10K NFT collection isn't just about digital art anymore. It's an army of unique warriors, each with special powers and abilities, ready to clash in epic card battles. We're talking Pokémon-style duels, Hearthstone-inspired strategy, and the thrill of competing with your very own creations.

But before we jump into the battle arena, we need to build it! This course is your game dev boot camp, where you'll learn how to transform your static NFTs into dynamic gaming assets, create an engaging battle system, and build a user-friendly interface that will captivate players.

![nft-battle.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/1%20What%20Are%20We%20Building%20Today/nft-battle.gif?raw=true)

## Why Embark on this NFT Game Adventure?

This course isn't just about having fun (though we'll have plenty of that!). It's also about leveling up your skills and diving headfirst into the booming world of Web3 gaming. By building your own NFT card battle game on Core, you'll:

- **Become an NFT Game Maestro**: Master the art of creating engaging, interactive experiences that leverage the power of blockchain technology.
- **Speak Solidity Like a Pro**: Deepen your understanding of Solidity, the programming language behind smart contracts, and learn how to create complex game logic on the blockchain.
- **Join the Web3 Gaming Revolution**: Be part of the cutting edge of gaming, where players truly own their in-game assets and communities are shaping the future of play.
- **Show Off Your Skills**: Build a portfolio-worthy project demonstrating your NFT game development and blockchain technology expertise.

## Core: Your NFT Gaming Powerhouse

And why Core blockchain? Well, it's not just about the vibrant community and the 80+ dApps already thriving on the network. Core's unique blend of Bitcoin's security and Ethereum's compatibility makes it the perfect platform for building your NFT card battle empire. You'll have the security and decentralization of Bitcoin, combined with the flexibility and functionality of Ethereum's smart contract ecosystem. It's a match made in blockchain heaven!

## Course Overview: Your Roadmap to NFT Game Dev Glory

Here's a sneak peek at the adventure that awaits you:

1. **NFT Game Mechanics Deep Dive**: We'll explore the core mechanics of card battle games and discuss how to design a balanced and engaging system.
2. **Smart Contract Development**: We'll roll up our sleeves and code the smart contract that will power your game, using the ERC-721 standard to seamlessly integrate your 10K NFT collection.
3. **Deployment to Core Testnet**: We'll launch your game on the Core testnet, where you can gather feedback and iron out any kinks before going live on the mainnet.
4. **Frontend Development**: We'll create a user-friendly interface that lets players unleash their NFTs in the arena, track their progress, and bask in the glory of victory.

## Who Should Join the Quest?

This course is tailor-made for:

- **Web3 Developers**: Whether you're a seasoned pro or just starting your journey, if you're passionate about blockchain and gaming, this course is for you.
- **NFT Enthusiasts**: Already own some NFTs? Great! Now you can learn how to take your passion to the next level and bring them to life in a game.
- **Core Community Members**: If you're part of the amazing Core community, this is your chance to contribute to the ecosystem and build something truly awesome.

## What's in It for You?

By the end of this course, you'll have:

- A deep understanding of NFT game mechanics and development
- The skills to write and deploy smart contracts on Core
- A working prototype of your very own NFT card battle game

## Proof of Completion

You'll receive a shiny new NFT badge to showcase your accomplishments after successfully finishing the course and all its requirements. It serves as verifiable proof of your newfound expertise in NFT game development on Core.

![core c4-nft.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/1%20What%20Are%20We%20Building%20Today/core_c4-nft.gif?raw=true)

## House Rules: Let's Keep It Fun and Productive!

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/Jf4ArqVb) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [Github](github.com/0xmetaschool), it would be a great support. 🫣
4. Stay happy and positive!

Alright guys, no need to wait any longer. Let’s get started!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/1.%20Battle%20Royale%20Fundamentals/1.%20What%20Are%20We%20Building%20Today.md

# Design the Game Logic and Set up Your Env

Alright, NFT champs! 🚀 You've mastered token standards, minted an epic 10K collection, and now it's time to level up again. We're diving headfirst into game development on the Core blockchain! Our goal? To create an engaging card battle game that leverages your awesome NFTs. 

![card.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/2%20Design%20the%20Game%20Logic%20and%20Set%20up%20Your%20Env/card.gif?raw=true)

Think **Pokémon meets Hearthstone** but with your unique 10K collection as the stars of the show.

In this lesson, we'll unveil the blueprint for your card battle dApp. We'll cover the specific game mechanics we'll use, how you'll leverage your existing NFT collection, and the development journey ahead. Get ready to unleash your inner game master!

## Card Battle Basics: Your NFTs Enter the Arena

At its core, our card battle game will be a thrilling showdown between your unique NFTs and a randomly generated computer opponent. 

![duel.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/2%20Design%20the%20Game%20Logic%20and%20Set%20up%20Your%20Env/duel.gif?raw=true)

Each NFT from your 10K collection will transform into a battle-ready card, boasting special attributes and powers. The computer opponent will also be represented by an NFT, generated dynamically using a predetermined set of rules and randomness.

Here's how a typical battle will unfold:

1. **Choose Your Champion:** Select an NFT from your collection to represent you in the arena. This NFT becomes your "champion" for the duel, ready to showcase its unique abilities.
2. **Meet Your Foe:** The game generates a random opponent using specific attributes and traits, creating a unique computer-controlled adversary for each battle.
3. **Random Stat Showdown:** A random stat, such as "strength," "speed," or "magic," is chosen. The champion's and opponent's stats for that category are compared.
4. **Victory or Defeat:** The NFT with the higher stat in the chosen category wins the battle! This simple yet engaging concept keeps players on their toes and adds an element of surprise to each match.

### Game Demonstration Video

🎥 **Coming Soon:** See your NFTs in action with our upcoming gameplay video!

## Integrating Your NFT Collection: From Art to Action

The beauty of this game lies in its seamless integration with your existing NFT collection. Each NFT you've painstakingly created now has a new purpose—a chance to prove its worth in the digital arena. This adds a whole new dimension to your collection, transforming it from static art into dynamic gaming assets.

Think of it this way: Your NFTs aren't just pretty pictures anymore; they're battle-hardened warriors, each with their own unique strengths and weaknesses. Whether it's their art, metadata, or other attributes, everything contributes to their in-game persona. Now, your NFTs have something to prove!

## The Smart Contract: The Game Master's Rulebook

![rules.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/2%20Design%20the%20Game%20Logic%20and%20Set%20up%20Your%20Env/rules.gif?raw=true)

The smart contract acts as the backbone of your card battle game. It will handle the core game logic, including:

- **Player Registration:** Allow players to join the game and link their NFT collection.
- **Battle Creation:** Facilitate the creation of battles between players and computer-controlled opponents.
- **Battle Resolution:** Determine the winner of each battle based on the chosen attribute and the NFTs' stats.
- **Record Keeping:** Track player wins and losses, potentially integrating a leaderboard or ranking system.

**Security Note:** The actual generation of the computer opponent's NFT will happen off-chain, and the stats will be securely passed to the smart contract to decide the winner. Ensuring the integrity and security of these interactions is crucial.

## The Development Roadmap: Your Path to Game Dev Glory

Now that we have our game plan, let's map out the development path that lies ahead:

1. **Setting Up Your Development Environment:** We'll get our hands dirty installing all the necessary tools and software needed to create a blockchain-powered game.
2. **Smart Contract Development:** We'll dive into the world of Solidity and craft the smart contract that will govern the game's rules and interactions.
3. **Deployment to the Core Testnet:** We'll deploy our game contract to the Core testnet for initial testing and feedback.
4. **Frontend Development:** We'll create a visually appealing and user-friendly interface for players to interact with the game.
5. **Gameplay Testing and Balancing:** We'll rigorously test the game, fine-tuning the mechanics to ensure a balanced and enjoyable experience for all players.

## Get Ready to Level Up Your Game Dev Skills!

In the next lesson, we'll dive deep into setting up your development environment, installing the necessary tools and software, and configuring your connection to the Core blockchain. Get ready to equip yourself with the skills and knowledge you need to create your own blockchain-powered card battle game. The future of Web3 gaming awaits! 🚀

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/1.%20Battle%20Royale%20Fundamentals/2.%20Design%20the%20Game%20Logic%20and%20Set%20up%20Your%20Env.md

Design the Game Logic and Set up Your Env

# Setting Up the Project Structure

Hello, future game dev wizards! 🚀 Get ready to transform those 10,000 unique NFTs into battle-ready warriors on the Core blockchain. In this lesson, we'll assemble the essential tools and software needed to create your epic card battle dApp. Think of it as setting up your game development HQ, complete with all the gadgets and gizmos needed to unleash your creativity and build an unforgettable gaming experience.

## Tool Time: Gathering Your Gear

There are a few tools that you need to install to proceed with the course. Make sure you have the following:

1.  Download & Install:
    1. [MetaMask.io](https://metamask.io/)
    2. [Node.js](https://nodejs.org/)
    3. [Visual Studio](https://code.visualstudio.com/)
        1. **Power-Up:** Install the "Solidity" extension. You can use the following extension.
            
            ![solidity-extension.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/1.%20Battle%20Royale%20Fundamentals/3%20Setting%20Up%20the%20Project%20Structure/solidity-extension.png?raw=true)
            
2. Connect Metamask to your Core Testnet with the RPC URL of [https://rpc.test.btcs.network](https://rpc.test.btcs.network/).
3. Fetch some tokens from the [Core testnet faucet](https://scan.test.btcs.network/faucet) by entering your wallet address to receive 1 CORE.

## Setting Up Your Project

We will first fork and clone the "build-nft-card-game-on-core" repo. Run the following command to setup the project. We have made a basic HardHat project for you with the empty files. You’ll have to implement the code in those files.

```
gh repo fork https://github.com/0xmetaschool/build-nft-card-game-on-core.git --clone
cd build-nft-card-game-on-core
npm install
```

Create a `.env` file in `build-nft-card-game-on-core` folder and add the following content to it. Replace `YOUR_PRIVATE_KEY` with your actual private key:

```
PRIVATE_KEY="YOUR_PRIVATE_KEY"
```

## That’s a Wrap!

Congratulations! You've successfully set up your development environment and are ready to embark on the exciting journey of building your own NFT card battle game on the Core blockchain. In the next lesson, we’ll delve into the specifics of smart contract development and begin crafting the logic that will power your game. Get ready to level up your game dev skills and create something truly epic!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/1.%20Battle%20Royale%20Fundamentals/3.%20Setting%20Up%20the%20Project%20Structure.md

Setting Up the Project Structure

# Smart Contract Architecture

Welcome back, architects of the blockchain! In the previous lesson, we set up our development environment and set up the project repository. Now, it's time to roll up our sleeves and start enhancing this contract with the necessary data structures and function outlines to bring our NFT-powered battle game to life! 💪

## Start building the cardgame battle contract
First, let's make sure we're in the right place. Navigate to the `contracts/` directory within your project folder. You’ll find the `CardGameBattle.sol` file there. 

![core c4.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4.jpg?raw=true)

This Solidity code defines a smart contract called `CardBattleGame`. It inherits from `Ownable` for ownership management and `EIP712` for standardized data signing. It interacts with an external NFT collection (`nftCollection`) and tracks battle IDs. The `CharacterClass` enum defines possible character types for the game. Think of it as creating a digital card game where players use NFTs as cards, and the contract manages battles and character types.

### Struct Players

Next, we have `Player` struct with fields for name, address, wins, losses, experience, and a mapping to store character statistics. It represents a player's profile in the card battle game.

This time, we have a few assignments for you. And believe me, you can do these very easily.

So let’s start with the first one. You need to replace YOUR_CODE_GOES_HERE in line `17` with the correct data type required for `name`.

**Hint:** Name will be a set of characters and we store those in what?? I know you can guess it, good luck! 🍀 

![core c4 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(1).jpg?raw=true)

### Character Stats ⚔️

Next, we need a way to represent the stats of each character (NFT) that players will use in battles. We have a `CharacterStats` struct that holds the core attributes of a character (NFT).

- `class`: Uses the `CharacterClass` enum to specify the character's type
- `level`: The character's current level.
- `exp`: The character's experience points, used for leveling up
- `health`, `mana`, `attack`, `defense`: Core stats that influence battle outcomes
- `wins` and `losses`: Track the character's individual win-loss record

**Assignment:** Replace YOUR_CODE_GOES_HERE in line `30` with the correct data type required for `mana`.

**Hint**: Mana is the power and it can increase up to 10,000. So what should be the data type?

![core c4 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(2).jpg?raw=true)

### Battles ⚔️

Let’s define `Battle` struct, which represents a battle between two players. It stores the following information. Think of it as a battle log where you record details about each match.

- `name`: A name or identifier for the battle.
- `player1` and `player2`: The Core blockchain addresses of the two players involved.ddd
- `player1TokenId` and `player2TokenId`: The IDs of the NFTs (characters) used by each player.
- `startTime`: The timestamp when the battle started
- `resolved`: A boolean flag indicating whether the battle has been concluded

**Assignment:** Replace YOUR_CODE_GOES_HERE in line `38` with the correct keyword.

**Hint**: What’s the keyword to define the structure of Battle?

![core c4 (3).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(3).jpg?raw=true)

### Mappings

Next, we have defined the constants for EIP712 signatures, a counter for total battles, and mappings to store player and battle data using their addresses and IDs as keys.

**Assignment:** Replace YOUR_CODE_GOES_HERE in line `49` with the correct struct.

**Hint**: What’s the name of the struct we defined for Players?

![core c4 (5).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(5).jpg?raw=true)

### Events

Next, we have defined events that emit information about player registration, battle creation, and battle resolution, allowing other applications to track game activity.

**Assignment:** Replace YOUR_CODE_GOES_HERE in line `52` with the correct data type.

**Hint**: In which data type do we store the name? Remember we did something similar before too.

![core c4 (6).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(6).jpg?raw=true)

### Constructor

The constructor function initializes the contract with the NFT collection address, sets up EIP712, sets the owner, and initializes counters for tracking battles. It's like preparing the game board before starting a new match.

![core c4 (7).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(7).jpg?raw=true)

### Key Functions: Orchestrating the Action 🎭

Now, let's outline the essential functions that will drive the battle mechanics in our smart contract.

- **registerPlayer:** Registers a new player, updates the player's name and address, and emits a `PlayerRegistered` event.
- **registerBattle:** Creates a new battle, initializes its details, updates the total battle count, and emits a `BattleRegistered` event.
- **resolveBattle:** Resolves a battle, updates player and battle stats, emits a `BattleResolved` event, and verifies the signature using EIP712.
- **_updateBattleStats:** Updates the players' stats involved in a battle, including experience, wins, losses, and character levels.
- **_levelUp:** Checks if a character's experience is sufficient to level up and updates their level accordingly.

![core c4 (9).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(9).jpg?raw=true)

The `external` visibility modifier allows you to use the functions only outside the contract. Private allows you to use the functions only inside the contract.

### Helper functions

The helper functions provide various functionalities within the `CardBattleGame` contract:

- **isPlayer:** Checks if a given address is a registered player.
- **getBaseHealth, getBaseMana, getBaseAttack, getBaseDefense:** Returns the base values for health, mana, attack, and defense based on a character's class.
- **getCharacterStats:** Retrieves the character statistics for a specific player and token ID.
- **getRequiredExp:** Calculates the required experience points to reach a specific level.

Other functions within the contract will use these functions internally to provide core game mechanics and data retrieval.

![core c4 (8).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture/core_c4_(8).jpg?raw=true)

Here, the `pure` keyword restricts the functions and does not allow the user to change any state variable of the contract nor read anything from the contract.

The `view` keyword only allows you to read from the contract but does not allow the user to modify the state of the contract.

## Compile and Check!

Let's make sure our contract is compiled without any errors. In your terminal, run the following command:

```bash
npx hardhat compile
```

> Find the solution to the assignments [here](https://github.com/0xmetaschool/build-nft-card-game-on-core/blob/solution-to-assignments/contracts/CardGameBattle_01.sol).

## Push your code

Now, as a best practice, lets push all our changes to git using the following command. These Git commands will add all your changes, create a commit with a descriptive message, and push your changes to the `boilerplate01` branch on your remote repository:

```
git add .
git commit -m "Added the basic data structures and function declarations"
git push -u origin boilerplate01
```

## Wrapping Up & Gearing Up for Implementation 🚀

We've now laid the architectural foundation for our NFT battle game's smart contract! We have the data structures to represent players, characters, and battles, and we've outlined the key functions that will drive the core gameplay loop.

In the next lesson, we'll dive deeper into the implementation of these functions, bringing the battle logic to life on the blockchain. Get ready to code, strategize, and conquer!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/2.%20Building%20the%20Battle%20Smart%20Contract/1.%20Smart%20Contract%20Architecture.md

Smart Contract Architecture

# The Battle Royale: Where NFTs Duke It Out

Welcome back, game masters! You've successfully laid the groundwork for your epic NFT battle arena. Now it's time to open the gates and welcome players into the fray! In this lesson, we'll focus on the initial steps of user registration and setting the stage for thrilling battles.

![battle.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/battle.gif?raw=true)

## Setting Up Your Right Branch

Run the following command to be at the `boilerplate02` branch:

```
git checkout boilerplate02
cd build-nft-card-game-on-core
```

Navigate to the `contracts/CardGameBattle.sol` and we’ll code there!

## Setting Up the Helper Functions

We need to add the functionality for player registration and battle preparation. But before that lets define a few helper functions so we can ease the code writing.

### isPlayer, getCharacterStats, and getRequiredExp

- `isPlayer`**:** Like checking if someone has a valid membership card to enter a club. This function determines if a given address belongs to a registered player.
- `getCharacterStats`**:** This function retrieves the character statistics for a specific player and token ID like checking a player's character sheet to see their current attributes.
- `getRequiredExp`**:** It calculates the required experience points to reach a specific level; similar to consulting a leveling chart in a game to determine the XP needed for the next rank.

![core c4 (12).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(12).jpg?raw=true)

### getBaseHealth, getBaseMana, getBaseAttack, getBaseDefense

These function retrieves the base values for health, mana, attack, and defense based on a character's class. Similar to looking up the base stats of a character in a role-playing game manual.

![core c4 (13).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(13).jpg?raw=true)

## The Grand Architect: Your Smart Contract

Imagine your smart contract as the blueprint for your game, the foundation upon which all the fun and excitement will be built. It's the rulebook, the referee, and the scorekeeper, all rolled into one. Let’s do it.

### registerPlayer

This function allows a new player to join the game. It checks if the player is already registered, then adds their name and address to the `players` mapping. Finally, it emits an event to notify other parts of the game that a new player has joined. Think of it like a person signing up for a new account on a gaming platform.

**Assignment:** Replace YOUR_CODE_GOES_HERE in line `64` with the correct variable name.

**Hint:** It’s the variable to store the name of the player.

![core c4 (14).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(14).jpg?raw=true)

### registerBattle

Imagine you're hosting a fighting tournament. `registerBattle` is like creating a new match. You give the match a name, assign the first player (you), and initialize the second player, character choices, and starting time. You then announce the match to everyone (emit the `BattleRegistered` event) and provide a unique ID for the match so others can join or watch.

**Assignment:** Replace YOUR_CODE_GOES_HERE in line `79` with the correct boolean value.

**Hint:** The battle is being registered and has not been started so can it be resolved?

![core c4 (15).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(15).jpg?raw=true)

### resolveBattle

The `resolveBattle` function is like the referee announcing the winner of a match. It verifies that the battle hasn't been decided yet, both players are valid, and they own the correct NFTs. It then checks the signature to ensure the result is legitimate. Finally, it updates the battle's status, player stats, and emits the result, similar to a referee declaring a winner and updating the scoreboard.

**Assignments**

1. Replace YOUR_CODE_GOES_HERE in line `106` with the correct variable.
    1. **Hint:** If there’s a single player, we need computer to play and if there are two, we need detail of the 2nd player. So do we have variable that checks if computer needs to intervene or not?
2. Replace YOUR_CODE_GOES_HERE in line `111` with the correct variable.
    1. **Hint:** Which `bytes32` variable did we define to store the hash?
3. Replace YOUR_CODE_GOES_HERE in line `118` with the correct boolean value.
    1. **Hint:** The battle is now registered and resolved so to what value should we update the `resolved` variable?

![core c4 (16).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(16).jpg?raw=true)

### _updateBattleStats

Imagine this function as a referee updating the scoreboard after a match. It determines who won and lost, awards points to the winner, and checks if either player has reached a new level.

`_updateBattleStats` updates the statistics of both players involved in a battle. It first determines the winner and loser, then updates their respective character stats. It increments the winner's experience, wins, and total experience, while incrementing the loser's experience and losses. Finally, it checks if either player has enough experience to level up and calls the `_levelUp` function for them.

**Assignments**

1. Replace YOUR_CODE_GOES_HERE in line `134` with the correct variable and arithmetic operation.
    1. **Hint:** So we had variable named `wins` and it should be increased now by 1.
2. Replace YOUR_CODE_GOES_HERE in line `142` with the correct variable and arithmetic operation.
    1. **Hint:** See line `135` where we increased the total wins for the winner. Now we need to do the same for the player who lost. But variable name will be changed.

![core c4 (17).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(17).jpg?raw=true)

### _levelUp

This function is used to check if a character's experience points are sufficient to level up. It takes a `CharacterStats` struct as input and updates the character's level if they have enough experience.

![core c4 (18).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/2.%20Building%20the%20Battle%20Smart%20Contract/2%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out/core_c4_(18).jpg?raw=true)

> Find the solution to the assignments [here](https://github.com/0xmetaschool/build-nft-card-game-on-core/blob/solution-to-assignments/contracts/CardBattleGame_02.sol).

## Wrap Up

With the core battle logic in place, we're ready to move on to the next exciting phase: creating the frontend interface. In the upcoming lessons, we'll design a visually stunning and user-friendly arena where your NFT warriors can clash, captivating players and collectors alike. Get ready to showcase your creativity and coding skills as we bring your card battle game to life!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/2.%20Building%20the%20Battle%20Smart%20Contract/2.%20The%20Battle%20Royale%20Where%20NFTs%20Duke%20It%20Out.md

The Battle Royale: Where NFTs Duke It Out

# Deploy to Core Testnet

Welcome back to another new lesson! Now that we are done with writing our smart contract, let’s deploy the contract on Core Testnet. Sounds interesting, right? Let’s get started!! 

## Compiling and Deploying the contract

Create a `.env` file in `build-nft-card-game-on-core` folder and add the following content to it. Replace `YOUR_PRIVATE_KEY` with your actual private key:

```
PRIVATE_KEY="YOUR_PRIVATE_KEY"
```

Let’s compile our contract using:

```
npm install
npx hardhat compile
```

### Deploying the Contract

Now finally, let’s deploy the contract on Core Testnet. Before deploying, make sure you have added Core testnet to your Metamask wallet and have funded it with test tokens as mentioned in the previous lessons. 

Navigate to `backend/ignition/modules/deploy.js` and we have the deployment file there. 

You can now deploy using:

```
npx hardhat ignition deploy ./ignition/modules/deploy.js --network core_testnet
```

It will ask to confirm the deployment. Press `y`. Once it's deployed, you will see something like below. Copy your deployed address.

![core c4 (19).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/3.%20Deployment%20and%20Frontend%20Integration/1%20Deploy%20to%20Core%20Testnet/core_c4_(19).jpg?raw=true)

## Checking Transaction on Block Explorer

We can use Core Scan to check our transactions. To do that, let’s go to [this](https://scan.test.btcs.network/) link.

Once you are there, paste the address you received in the previous step in the search bar. You can now see that you have made the transaction: 

![Screen Recording 2024-07-25 at 10.33.32 AM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/3.%20Deployment%20and%20Frontend%20Integration/1%20Deploy%20to%20Core%20Testnet/Screen_Recording_2024-07-25_at_10.33.32_AM.gif?raw=true)

## Verifying our Contract

To verify the contract, we first need to add our API Key from Core Scan to our `.env` file. Let’s see how we can do that:

- Go [here](https://scan.test.btcs.network/) and create your account
- Once your account is created, when you go to your profile, you will see an option API-KEYs.
    
    ![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/3.%20Deployment%20and%20Frontend%20Integration/1%20Deploy%20to%20Core%20Testnet/Untitled.png?raw=true)
    
- You can now click on `add` and create your API Key, we have named it `my_key`, but you can name it anything you want.
    
    ![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/3.%20Deployment%20and%20Frontend%20Integration/1%20Deploy%20to%20Core%20Testnet/Untitled%201.png?raw=true)
    

Once we have our key, let’s copy it and paste it into our `.env` file by assigning it to `API_KEY`

Our `.env` file now looks like this:

```
PRIVATE_KEY = "YOUR_PRIVATE_KEY"
API_KEY="YOUR_API_KEY"
```

We are now finally ready to verify our contract! We need to follow just one last step to verify our contract. To do that, you can simply follow the steps given below:

1. Replace YOUR_CONTRACT_ADDRESS below with the deployed contract address you got during the last step. 

2. Complete our third course [Launching a 10K NFT collection on Core](https://metaschool.so/courses/launch-10k-nft-collection-on-core) of Core learning track. In the lesson, [Compiling and Deploying Contract](https://metaschool.so/courses/launch-10k-nft-collection-on-core/lesson/169dd4e0-1ee3-432e-84c7-6232bee99b16), you deployed the code and a deployed address for the smart contract was created. Replace NFT_CONTRACT_ADDRESS with that.

```
npx hardhat verify --network core_testnet YOUR_CONTRACT_ADDRESS NFT_CONTRACT_ADDRESS
```

Once it's verified, you will see something like below:
![core c4 (21)](https://github.com/user-attachments/assets/dbf2a3d6-44f7-4cdb-9606-e087be8b40e8)

## Pushing it to Git

Now, as a best practice, let's push all our changes to git using the following commands:

```
git add .
git commit -m "Smart contract coded completely"
git push -u origin boilerplate02
```

## Wrap Up

Congratulations!! You have achieved a lot in this lesson! From compiling the contract to deploying it and even verifying your contract. You have done it all! You have even checked your transaction on Core Scan. Well done! In the next lesson, we will interact with the frontend. See you there!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/3.%20Deployment%20and%20Frontend%20Integration/1.%20Deploy%20to%20Core%20Testnet.md

Deploy to Core Testnet

# Connect Smart Contract to Frontend

Victory awaits, brave adventurers! We've forged the logic to determine battle outcomes in the previous lesson, and now it's time to connect the dots between our frontend dApp and the deployed battle contract on the blockchain.  This crucial link will allow us to tap into the contract's power and bring our game to life! ✨

![Course-media.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/3.%20Deployment%20and%20Frontend%20Integration/2%20Connect%20Smart%20Contract%20to%20Frontend/Course-media.gif?raw=true)

Alright, now that we have prepared all the code, let’s see how all this looks in our application. 

## Pre-requisites

Make sure to complete our third course [Launching a 10K NFT collection on Core](https://metaschool.so/courses/launch-10k-nft-collection-on-core) of Core learning track. In the lesson, [Compiling and Deploying Contract](https://metaschool.so/courses/launch-10k-nft-collection-on-core/lesson/169dd4e0-1ee3-432e-84c7-6232bee99b16), you deployed the code and a deployed address for the smart contract was created. Make sure you have that. Additionally, we also need the ABI of the deployed smart contract, which can be found in the `backend/artifacts/contracts/CoreNFT.json` file.

## Prepare the Artifacts
Do the following steps:
1. Navigate to `/client/src/`.
2. Create `artifacts` folder.
3. Copy the `backend/artifacts/contracts/CoreNFT.json` to `/client/src/artifacts` folder.
4. Copy the `/artifacts/contracts/CardGameBattle.sol/CardBattleGame.json` file and paste it to `/client/src/artifacts`. Our application will use the ABIs contained in those `.json` file to interact with the respective contracts.

## Set Up Environment Variables

Now, in the `/client` directory, create a `.env` file and copy the following content. Against these variables:

1. Add the contract address of the `CardBattleGame` contract against `VITE_GAME_CONTRACT`
2. Your Metamask account private key against `VITE_PRIVATE_KEY`.
3. Add the contract address of the `CoreNFT` contract from third course against `VITE_NFT_CONTRACT`.

```
VITE_GAME_CONTRACT=""
VITE_PRIVATE_KEY=""
VITE_NFT_CONTRACT=""
```

## Install Dependencies and Run the App

And there you go, you are all set to run your frontend application! So navigate to the `/client` directory and run the following commands:

```
npm install
npm run dev
```

This will run your frontend application. You can access it at `http://localhost:5173`.

Connect your Metamask and with the new features in place, players can now:

- **View their NFT collection:** On the homepage, players will see a carousel showcasing their owned NFTs.
- **Select a card for battle:** They can interact with the carousel to choose the NFT they want to use in a battle.
- **Create or join battles:** The "Battle Arena" section now allows players to create new battles by providing a name. Additionally, they can see a list of available battles and join one by clicking the "Join Battle" button.

![boilerplate03.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Battle%20Royale%20-%20core%20C4/3.%20Deployment%20and%20Frontend%20Integration/2%20Connect%20Smart%20Contract%20to%20Frontend/boilerplate03.gif?raw=true)

## That’s a Wrap

We've successfully bridged the gap between our frontend and the smart contract, enabling us to fetch and display crucial battle information. With this foundation in place, we're now ready to empower our players to select their cards and initiate epic battles! In the next lesson, we'll conclude our course.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/3.%20Deployment%20and%20Frontend%20Integration/2.%20Connect%20Smart%20Contract%20to%20Frontend.md

Connect Smart Contract to Frontend

# 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. Let's summarize what you've learned till now.

## Building Battle Royale game

One of the most interesting parts of the course was that we learnt how to transform your static NFTs into dynamic gaming assets, create an engaging battle system, and build a user-friendly interface that will captivate players.

## Deploy and Interact with Contract

Another super interesting part filled with learning, was when we deployed our contract on Core and interacted with it through frontend. And that’s how we built a full-fledged project which not only creates a contract but also interacts with it through our frontend.  

## ⚒️ A small yet important request

Here is great news for you! 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). If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://bit.ly/core-course-discord) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our [repository](https://github.com/0xmetaschool/Learning-Projects). 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/core-course-twitter) and [LinkedIn](https://bit.ly/core-course-linkedIn) as well. 🫶
3. Subscribe to our [YouTube](https://bit.ly/core-course-youtube) channel for exciting videos.

Also, now that you have a strong understanding of Core, Why don't you take the next step and become an active participant in the Core ecosystem? Here's how you can get involved and make your mark:

1. Join their [Telegram channel](https://t.me/CoreDAOTelegram), [Discord channel](https://discord.com/invite/coredaoofficial).
2. Follow Core Chain on [X](https://twitter.com/Coredao_Org), [X account for Devs](https://x.com/corechain_devs), and subscribe on the [YouTube](https://www.youtube.com/@Core_DAO_Official) channel.
3. Contribute directly to the CoreDAO [Github Repository](https://github.com/coredao-org).

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the in-depth knowledge to start building in the exciting world of Core. We wish you luck!

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Battle%20Royale%20%E2%80%93%20Building%20a%201v1%20Card%20Battle%20Dapp%20on%20Core/4.%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

Master Core Development, Secure the Future

AI Templates

TicTacToeGPT

MockInterviewerGPT

CSSGeneratorGPT

FinanceGPT

LearnLanguageGPT

Castle.ai

FlashcardGPT

DatingCoachGPT

TriviaQuizGPT

CrosswordGPT

AI Tools

Master Core Development, Secure the Future