A series of carefully designed courses to help you learn and excel in the Aptos Move programming language so that you can build your next big Web3 idea.

Learn to Build on Aptos, Make Your Move

Prepare for an exciting adventure as you build a Documents Management dApp on the Aptos blockchain! This course is your gateway to mastering Aptos development through a hands-on project. From setting up your environment to deploying your dApp, you’ll gain practical experience with Move programming, smart contracts, and the Aptos ecosystem. Discover how to use constants, variables, structs, and functions to create a powerful application, and master document state management along the way. Get ready to dive into Aptos development and elevate your skills with Aptos Move!

# What Are We Building Today

GM everyone! ☀️ We’re super excited to kick off the fourth, yes fifthhh course in our detailed series on Aptos for developers here on Metaschool. First things first, let’s give you a big round of applause for completing the FOUR courses on Metaschool Woohoo! 🎉

Pro move: Savvy blockchain enthusiasts know the value of following project repos on [GitHub](https://github.com/aptos-labs). It's a great way to stay ahead of the curve and potentially catch some interesting opportunities like airdrop maybe!

![woohoo-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/1.%20Introduction%20and%20DApp%20Overview/1%20What%20Are%20We%20Building%20Today/woohoo-ezgif.com-optimize.gif?raw=true)

We know that Aptos is a layer-1 blockchain boasting over 3.9 million monthly active users and more than 983 million transactions to date. With over 170 projects spanning various sectors such as DeFi, NFT tooling, gaming, wallets, stablecoins, and marketplaces, Aptos is a vibrant ecosystem. We are excited to assist you in launching another of your projects on the Aptos platform.

![Slide8.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/1.%20Introduction%20and%20DApp%20Overview/1%20What%20Are%20We%20Building%20Today/Slide8.jpg?raw=true)

We’ve delved into the Aptos blockchain and mastered its programming language basics. We’ve even built a calculator, a fungible token, and a rock-paper-scissors game on Aptos! Now, it's time to take things to the next level with an exhilarating challenge. Get ready to unleash your creativity and skills as we dive into developing an advanced project: a thrilling dApp for contract management.

Just for your excitement, I have added a GIF that shows how we will interact with our token. But here’s the vercel link too so you can interact live with the dApp.

## The Aptos Move Contract

But why build a contract management dApp, you ask? Buckle up, because here's why:

- **Hands-on Learning:** Writing a contract is an engaging and practical way to grasp Aptos blockchain concepts.
- **Deployment and Interaction:** The excitement doesn't stop at coding! You'll deploy your contract onto Aptos, interact with it on the Explorer, and see your code come to life in a decentralized environment.

### Features of document management dApp

This course will equip you with the knowledge and skills to build the following functionalities of a contract management dApp on Aptos Move:

- Create document
- Sign the document
- Get any document information you want

## Course Overview

We will:

1. Do a quick run-through of what we have covered so far.
2. Get your tools and workspace ready for development.
3. Build the foundations of the contract.
4. Add functionalities for setting up the document management dApp.
5. Deploy and Interact with the contract on Aptos Testnet Explorer.
6. Add frontend and interact with the dApp in real time.

## Who exactly should take this course?

This course is for  Web3 developers who wish to dive deeper into the Aptos world and have completed our three two courses on Aptos. 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?

As a developer, you will be getting the following outcomes when you complete this course:

1. Utilize Move to build on Aptos
2. Build the document management dApp
3. Claim your NFT upon course completion

## Proof of completion

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

![aptos c5 nft.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/1.%20Introduction%20and%20DApp%20Overview/1%20What%20Are%20We%20Building%20Today/aptos_c5_nft.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!

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

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Documents Management DApp on Aptos/1. Introduction and DApp Overview/1. What Are We Building Today.md

What Are We Building Today?

# Documents Management in Blockchain

Welcome back, rockstars! We’re so proud of you for continuing your journey with us! This is your fifth course on the Aptos series, like, wow, you’ve achieved so much so far!!

First, we’re going to discuss what we’re going to build in this course. This is going to be the advanced course in our Aptos series. So, buckle up, take an energy drink, and get ready for some excitement.

## What the hell is document management?

Before we proceed and start building, let's first understand what document management is. We'll begin by discussing the problem using an example and then explore how document management solves it.

### The Problem

You're about to launch a new product, and the team is dealing with many documents—contracts, design specs, marketing plans. But things quickly get messy. Files are scattered across emails, different folders, or even on various team members’ desktops. Tracking the latest versions, getting everyone to review and sign off, and ensuring nothing important gets lost or overlooked becomes a time-consuming hassle.

### The Solution

This is where document management comes in. Imagine you have a system that stores all these documents in one secure, organized place. Instead of hunting for the latest version of a contract, you can find it instantly. Your team can collaborate on documents in real-time, with changes automatically tracked so nothing gets lost. When a document needs approval, the system sends out reminders and locks the document once everyone has signed it.

## Documents management in blockchain

Imagine you managed to manage your documents in multiple Word files but is it secure enough that no one can change it? What if you accidentally share the edit link with anyone? They could change the sign, change what is written in the document, or anything else.

![Slide9.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/1.%20Introduction%20and%20DApp%20Overview/2%20Documents%20Management%20in%20Blockchain/Slide9.jpg?raw=true)

Here’s where the blockchain comes in. Blockchain can help you securely create a document and get it signed by anyone without allowing anyone to change the document's contents.

## Documents management dApp features

As discussed in the first lesson as well, we will create the dApp that can manage the documents from start to end on the Aptos using Aptos Move. 

We will build a contract that will be particularly useful in scenarios where multiple parties need to sign a document before it is considered valid or completed. 

![Slide2.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/1.%20Introduction%20and%20DApp%20Overview/2%20Documents%20Management%20in%20Blockchain/Slide2.jpg?raw=true)

For example:

- **Legal Agreements:** Where multiple parties must sign a contract before it is executed.
- **Approval Processes:** Where different stakeholders need to approve a document or proposal.
- **Multi-Signature Verification:** In cases where a document requires signatures from multiple trusted entities.

## Documents management dApp contracts

So, in our dApp, we will have only one contract, that can do all of the stuff we discussed above. 

The contract will have the following functionalities:

1. Initialize the store which we will use to store all the data of the document.
2. Create a document and allow users to create a document.
3. Allow users to sign the document with ease.
4. Allowing users to get the information on the document.

The following visual shows all the functions we’re going to implement.

![Slide3.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/1.%20Introduction%20and%20DApp%20Overview/2%20Documents%20Management%20in%20Blockchain/Slide3.jpg?raw=true)

One more thing, you must be confused that how are you going to save all the big content of a document in a variable of the contract. For this, we will utilize the IPFS. We will save the document file in an IPFS and then store the hash in our contract along with the signers.

## Where to use the dApp

This module is the perfect fit for those looking to manage documents with multiple signers in their dApp. Whether for legal, financial, or admin apps where trust is non-negotiable, it ensures that signatures are transparent, secure, and permanently recorded on the blockchain. If your app demands rock-solid trust and audibility, this module delivers!

## That’s a wrap

That’s it, folks!! You’re all equipped with the information of what we will build in this course. Next, we will begin construction and set up our environment.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Documents%20Management%20DApp%20on%20Aptos/1.%20Introduction%20and%20DApp%20Overview/2.%20Documents%20Management%20in%20Blockchain.md

Documents Management in Blockchain

# Setting Up the Dev Wizard

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 Aptos testnet. 

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. So, let's get started!

## 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. [Petra wallet](https://petra.app/)
    2. [Aptos CLI](https://aptos.dev/en/build/cli)
    3. [Node.js](https://nodejs.org/)
    4. [Visual Studio](https://code.visualstudio.com/)
2. Make sure you are using the Aptos testnet network in the Petra wallet.
3. Fetch some tokens from the Aptos testnet faucet by clicking on the faucet option available on your wallet.

## Setting up your project


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 your terminal where you configured your Git CLI - following the previous lessons, run the following command:

```
gh repo fork https://github.com/0xmetaschool/contracts-management-aptosc5 --clone
cd contracts-management-aptosc5
```

This will clone the boilerplate code of your project onto your system and fork the repository to your Git account as well. And we will change the folder to this cloned repo.

We will first make sure that we are at the right branch. Run the following command to be at the `boilerplate01` branch. 

```
git checkout boilerplate_01
```

At `boilerplate_01`, we have made a basic Aptos Move project for you with the basic move file. You’ll have to implement the code in those files.

![aptos-structure.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/2.%20Project%20Structure%20and%20Setup/1.%20Setting%20Up%20the%20Dev%20Wizard/aptos-structure.png?raw=true)

The next thing we need to do is set up our Aptos CLI to work with our account. We'll use the `aptos init` command inside our directory.

1. You’ll be prompted to choose a network when you run the above command. Type `testnet` and press “Enter”.
2. Next, provide your private key we copied in the last lesson when prompted and hit enter.

And there you have it! The Aptos CLI is successfully set up. 

![aptos 03.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/2.%20Project%20Structure%20and%20Setup/1.%20Setting%20Up%20the%20Dev%20Wizard/aptos_03.jpg?raw=true)

## That’s a wrap

High-five, coding champ! You've just set up your Aptos Blockchain development environment like a pro. You've installed Node.js, VSCode, Aptos CLI, and connected your Petra wallet to the Aptos testnet.

That wasn't so scary, was it? You're officially part of the growing community of Aptos Blockchain developers building the future of decentralized finance. See you in the next lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Documents%20Management%20DApp%20on%20Aptos/2.%20Project%20Structure%20and%20Setup/1.%20Setting%20Up%20the%20Dev%20Wizard.md

Setting Up the Dev Wizard

# Implement the Document Management Contract

Welcome back, rockstars!! You’ve been great so far!! You’re all set to code your first document management dApp in Aptos Move.

Buckle up and get ready to implement the Move code.

## Let’s start implementing the contract

Head over to the `boilerplate_01/sources/hash_sign.move`. This is where we will implement the contract code for document management dApp. Please do make sure that you fill in all the code and don’t miss anything.

### Import the dependencies

First of all, we will start with importing the dependencies that will help us implement the contract code.

![hashsign-hashSign.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashsign-hashSign.png?raw=true)

### Define the structures

After importing the dependencies, we will implement the structs that will help build the dApp and store the important information.

![structss.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/structss.png?raw=true)

### Define events

We have declared all the important structures so far. Now, we will declare the events but using the `struct` keyword that will have the `drop` and `store` abilities.

![hashSign-eventsss.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashSign-eventsss.png?raw=true)

Now, you are done with setting up the basics. It is time for actual implementation now. 

Please don’t forget to replace your code with the `YOUR_CODE_GOES_HERE`. We have also mentioned the assignment numbers in the coding file and instructions for the code you have to implement in the comments for your ease.

### Define the constructor function

First of all, we will implement the constructor function. Let’s call it `init_module`. It will take in the `account` as a parameter, initialize the `GlobalDocumentStore` struct and `EventStore`, and move them to the signer account.

Implement your first assignment here.

![hashSign-init.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashSign-init.png?raw=true)

### Define the create document function

Now, we will implement the create document function which will help us initialize the `Document` struct will all the information that we will take from the user. It will store the document in a vector array so that the document remains secure and the user doesn’t get direct access.

Implement all the missing code and complete the 2nd to 6th assignments.

![hashSign-createDoc.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashSign-createDoc.png?raw=true)

**Don’t worry!** If you don’t get the solution. We will share the full solution with you in the next lesson.

### Define the sign document function

The `sign_document` function will help us sign the document. This means we will use this function to get the signatures of the authorities. We will use the `Signature` struct here and the `SignDocumentEvent` to complete the signature process.

Implement the missing parts of the code and complete the 8th to 11th assignments.

![sign-doc.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/sign-doc.png?raw=true)

### Define the get document functions

Here, we will define three different function which help us retrieve the information of the document.

1. The `get_document` function will help us return the information of the document. The user passes the document ID to get the relevant document information.
2. The `get_all_documents` function will help us retrieve the information of all the documents
3. Lastly, the `get_total_documents` function will help us to retrieve the total number of documents created by the user.

Don’t forget to implement the assignments. We tried to keep them easy for your ease.

![hashSign-getDoc.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashSign-getDoc.png?raw=true)

### Overall, here’s how the contract works

This is how it will work:

- **Initialization:** A user will call the `init_module` to set up a `DocumentStore` in their account.
- **Document Creation:** The user creates a document by calling `create_document` with the document's content hash and the list of signers.
- **Signing Process:** Each authorized signer calls `sign_document` to sign the document. The system ensures that only authorized signers can sign and that the document isn't signed more than once by the same signer.
- **Completion:** Once all signers have signed, the document is marked as completed, preventing further signatures.

## Compile and deploy

Let’s go ahead and deploy the contract you implemented using the CLI. 

### Update `Move.toml`

First things first, we need to add our wallet address. So go to the `Move.toml` and update `Replace_with_your_wallet_address_🔑` with your wallet address.

![hashsign-movetoml.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashsign-movetoml.png?raw=true)

### Deploy the code

Now open a terminal in the `contracts-management-aptosc5` folder and run the following command:

```jsx
aptos move compile
```

The command will essentially compile our code and if the compilation is successful that means our code is mostly error-free and ready to be pushed to a network. The output will look like this:

![hashSign-compile.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashSign-compile.png?raw=true)

If you face an error while compiling the contract, try running the following command.

```
aptos move compile --skip-fetch-latest-git-deps
```

### Publish the contract

The following command will publish our code to the Aptos testnet. While running the command, it will prompt you regarding the transaction fee payment, just add a ‘yes’ there.

```jsx
aptos move publish
```

And once that is done, the CLI will automatically publish the code to the Aptos testnet. The output will look like this:

![hashSign-publish.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract/hashSign-publish.png?raw=true)

If you face an error while publishing the contract, try running the following command.

```
aptos move publish --skip-fetch-latest-git-deps
```

We are done with the contract part. Let’s explore how to use it in the frontend in the next lesson.

## Push your code

Implement the complete code of the `HashSign.move` contract and push it to the `boilerplate_01` branch. You can follow the following commands.

```
git add .
git commit -m "Done with the implementation of HashSign.move"
git push -u origin boilerplate01
```

## That’s a wrap

Phew!! You’re done with all the backend implementation for your dApp. Next, we’ll check the solution to our assignments and start setting up the frontend.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Documents%20Management%20DApp%20on%20Aptos/3.%20Building%20the%20Document%20Management%20DApp/1.%20Implement%20the%20Document%20Management%20Contract.md

Implement the Document Management Contract

# Contract Management Functionality Frontend

Hey, welcome back! In the previous lesson, we completed our backend code and implemented the `HashSign` module. Now it’s time to see the solution to our assignments and add the front end to our code. Are you in it with me? I’m sure it’s a YES, so let’s go!

## Check the solution code

To view the solution and run our front end, we need to fetch the `boilerplate_02` branch of our GitHub repo. So, run the following command.

```
 git checkout boilerplate_02
```

If your code worked fine in the lesson then you’re good to go, If not please check out the solution code and try publishing it. You can find the solution code in the `hashSign/sources/HashSign.move` file.

![aptos-frontend.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/aptos-frontend.png?raw=true)

Before publishing the contract, do not forget to update the `HashSign` address with your wallet address in the `Move.toml` file.

## **Frontend Prep-work**

We can create frontend using the command `npx create-react-app interface --template typescript` but will we? Well, it’s your choice, we already have a frontend setup in the git repo you cloned. 

- You can explore more about the frontend project creation from [Aptos’ official documentation](https://aptos.dev/en/build/create-aptos-dapp).

Run the following command to go to the frontend folder:

```jsx
cd frontend
```

Here’s what the frontend structure looks like:

![aptos-frontend-3.1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/aptos-frontend-3.1.png?raw=true)

## Important frontend

We’ll explore a few important files, the rest is UI and wallet handling that we have covered in [**Build Rock Paper Scissor Dapp on Aptos**](https://metaschool.so/courses/build-dapp-on-aptos). 

If you navigate to the `components` folder, you will find `ContractManagement.tsx` and `SigningDocument.tsx`. 

![aptos-frontend-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/aptos-frontend-2.png?raw=true)

These files are important in terms of the front-end implementation of our backend code. Let’s see what these do.

1. The React component, `ContractManagement`, handles document management on Aptos blockchain. It allows users to create documents, add signers, upload files to Pinata, and submit transactions for document creation and signing. It also fetches document data, displays document information and pending signatures, and provides a sharing feature.
2. The React component, `SigningPage`, allows users to view and sign documents on Aptos blockchain. It fetches a specific document based on the URL parameter (`id`). It displays the document content, creator, status, and number of required signatures. The user can sign the document if they are listed as a signer and haven't signed yet.

## Set up the environment variables

So, now we need to set up the environment variables. Find the `.env` and start setting it up.

![aptos-frontend-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/aptos-frontend-4.png?raw=true)

1. First, we have `VITE_APP_MODULE_NAME`. Please make sure that you use the same module name here you published to the aptos testnet network.
2. Do not change `VITE_APP_NETWORK`, keep it the `testnet` network.
3. Please use your wallet address for `VITE_APP_MODULE_ADDRESS`. Same as you used the wallet address as your module address while publishing the move contract.

## Set up Pinata IPFS

Next, we will set up the Pinata so that we can store our documents in the IPFS and use the API keys in the frontend.

So what is a Pinata? Its a peer-to-peer database storage system. Here, we save our data and access it using a URL. Unlike centralized storage, data in this system is distributed across multiple computers called peers. Okay so, here’s what we’re gonna do.

1. Sign up for Pinata
2. Create new API keys
3. Fetch the keys
4. Add the keys to the `.env` file

So, we have given you an overview here. Let’s move on to actually doing it.

### Signup to Pinata

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

1. Click on the “Start Building” button. It will take you to the sign-up page.
2. Enter your email address, select “Builder” in the title section, and move “Next.”
3. Set your first name, last name, and password.
4. Confirm your email by entering the confirmation code.
5. Your Pinata profile is ready to go. Here’s what it will look like:
    
    ![pinata-1.1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/pinata-1.1.png?raw=true)
    

### Create new API keys

Next, we need to create new API keys so that we can use them to connect to Pinata in the front end.

1. Go to the “API Keys” section on the sidebar.
    
    ![pinata-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/pinata-1.png?raw=true)
    
2. Click on the “+ New Key” button on the top right.
    
    ![pinata-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/pinata-2.png?raw=true)
    
3. On the “Create API Key” page, enter your project name as the key name and give the Admin rights. Finally, click the “Generate API Key” button to generate the keys.
    
    ![pinata-3 (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/pinata-3_(1).png?raw=true)
    
4. Lastly, copy the “API Key” and “API Secret” and paste them in the `.env` file.

```
VITE_APP_PINATA_API_KEY=YOUR_PINATA_API_KEY
VITE_APP_PINATA_SECRET_API_KEY=YOUR_PINATA_SECRET_KEY
```

## Run the frontend

Finally, we will run the frontend application now. Make sure you are at the `contracts-management-aptosc5` folder and run the following commands.

```
npm install
npm run dev
```

You will see the following page after running the app.

![frontendd.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/frontendd.png?raw=true)

Connect your wallet, the same wallet you used to deploy the contracts and create a document by uploading the documents and adding the signer address.

![create-doc.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/create-doc.gif?raw=true)

After uploading the documents you can view the document in the “Your Documents” field. Now, go to the “Pending Signatures” field and click on the “Sign Document” to sign the document.

![sign-document.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend/sign-document.gif?raw=true)

## That’s a wrap

Great work, rockstar!! You are all set! You’ve not only implemented the contracts but also integrated them with the frontend. You are awesome! Next, we’ll just wrap up the course and see what we have done so far.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Documents%20Management%20DApp%20on%20Aptos/3.%20Building%20the%20Document%20Management%20DApp/2.%20Contract%20Management%20Functionality%20Frontend.md

Contract Management Functionality 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 and how it can empower you in the world of blockchain development.

## What We Covered

- **Introduction:** Got an overview of what we will build and the course structure.
- **Overview of Aptos World:** We revised why Aptos, Move, and its features are bringing change to the web3 world.
- **Aptos SDK:** We understood the Aptos SDK support for the frontend part and what features it has for us and how can we utilize them to create our dApp.
- **Getting Started with Development:** Learnt how to set up our development environment using the Aptos CLI. We installed the necessary tools and created a wallet.
- **Create, deploy, and interact with dApp:** We wrote the contract for our dApp and utilized the randomness feature of Aptos. We deployed it to front end and interacted with it.

Yes, we did this all! Cheers~

![aptos-c4-l10.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Documents%20Management%20DApp%20on%20Aptos-C5/4.%20Wrap%20Up/1.%20Let%E2%80%99s%20Wrap%20It%20Up/aptos-c4-l10.gif?raw=true)

## ⚒️ A small yet important request

Here is 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/stacks-course) and [LinkedIn](https://bit.ly/stacks-course-linkedin) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos. ✨

## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Documents%20Management%20DApp%20on%20Aptos/4.%20Wrap%20Up/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Let’s Wrap It Up

Build Documents Management DApp on Aptos

This comprehensive course is for you to explore the innovative Aptos blockchain and build exciting real-world dApps. In this course, you will learn about Aptos's fascinating history, from its origins and key contributors to its role within the Move ecosystem and its relationship with Diem. You will also discover its unique features, architecture, and components, gaining insights into its mission, vision, and design principles. Lastly, this course will help you learn how Aptos is compared to other blockchain platforms in terms of scalability, security, and performance. Enroll now.

# What are We Learning Today?

Hey there fellas 👋, today marks the first day of our journey to learn and master the Aptos blockchain. In the Ohlone language, "Aptos" means "The People.” This meaning fits right in as Aptos is a Layer-1 blockchain for everyone.

Quick tip: Keeping an eye on official blockchain GitHub repos like Aptos can be incredibly rewarding. Many projects offer airdrops and incentives to active community members. Don't miss out - follow [Aptos on GitHub](https://github.com/aptos-labs)!

![image21.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20are%20We%20Learning%20Today/image21.gif?raw=true)

Great! But Why Aptos 🤔? Well, when you have a Layer-1 protocol that is backed by almost 400 million dollars in total locked value and one that has a market cap of nearly $4 billion, and daily average transactions hitting 500K. It's no surprise we're launching this course now so that developers, like you can master this protocol, build on it, and even tap into the millions of dollars in grants the Aptos Foundation offers to exciting projects within their ecosystem. It’s time to *make your Move* 💪 Indeed!

![image30.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20are%20We%20Learning%20Today/image30.gif?raw=true)

## Course Overview

In this introductory Aptos Course, we will learn about :

📖 History of Aptos

⚙️ Features of Aptos

🕹️ Cool DApps built on Aptos

🏗️ Aptos Architecture

💪 How Aptos compares to other blockchains.

💡 Advantages of building on Aptos

## Who Exactly Should Take This Course?

This course is for beginner web3 developers who wish to learn about Aptos. You don't need any prior knowledge whatsoever, just stay committed to learning and understanding the concepts. If you want to create your decentralized apps and be part of the growing Aptos community, this course is for you 🫵.

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

Before we attempt to create some cool DApps on the Aptos blockchain, it is important to understand the perks offered by Aptos. You cannot fully utilize a tool until you have a good understanding of the functionalities it has to offer.

Another reason is that there are a bunch of blockchains out there, each with unique perks so it is quite important to distinguish amongst all these options.

![image42.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20are%20We%20Learning%20Today/image42.gif?raw=true)

Aptos stands out with its scalability, robust security measures, and thriving ecosystem, making it a prime choice for developers aiming to make a mark on the Aptos blockchain. Well, we are not bluffing at all, just stay with us till the end of the course and you will know why…

We have built this comprehensive course just for you to help you build a solid foundation of the Aptos. We cannot wait for you to get started and have fun learning from this course.

## Proof of Completion

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

![image36.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20are%20We%20Learning%20Today/image36.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!

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


https://github.com/0xmetaschool/Learning-Projects/raw/main/Aptos%20C1%20Introduction%20to%20Aptos/1.%20Course%20Introduction/1.%20What%20are%20we%20learning%20today.md

What are We Learning Today?

# History of Aptos

Hey there, fellow developers! We're super excited to have you here with us on this course.

Now, imagine we asked you to list the top three things you look for in a "Good" blockchain project. You might mention the number of pages in the white paper, how active the founders are on Twitter, or when they're planning their next airdrop or mainnet launch.

![image12.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image12.gif?raw=true)

We get it — these factors are important! But there's one element that's often overlooked: a good origin story.

![image31.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image31.png?raw=true)

A solid origin story can tell you so much about a project. It reveals the vision behind the initiative, the problems it aims to solve, the people involved, and their motivations for driving the project forward.

So, as we embark on this epic quest to learn and master the Aptos blockchain, we think it would be fantastic to start with the story of Aptos and how it evolved into one of the most prominent blockchain protocols in the space.

![image11.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image11.png?raw=true)

So, let's just dive right in and discover not just the 'what' and the 'how,' but also the 'why' behind Aptos!

## A Facebook Project

Not so long ago, in 2019, Meta, formerly Facebook, officially announced that they were planning to launch a blockchain-based global payment system called Libra, with its stablecoin.

![image43.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image43.png?raw=true)

The idea was to make sending money across borders as cheap and easy as possible. You can imagine the buzz—it made people super excited and skeptical.

But the skepticism wasn't just from everyday folks; governments and regulators were on high alert, too. They started raising concerns right away. Could this huge project disrupt national currencies? What about the risks of money laundering? These concerns quickly turned into a massive storm of opposition to the project.

To calm things down, Facebook made some significant changes. They rebranded Libra as Diem, shifted their focus to single-currency stablecoins, and overhauled the project’s governance. But, even with these changes, the headwinds continued. Key partners started to back out, and Facebook, feeling the heat, began to waver.

By January 2022, it was over for the Diem Association. They sold their assets, officially putting an end to the project. But our story doesn't end there!

![image9.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image9.png?raw=true)

## A Bold Move

You see, many of the engineers and developers who spent years on the Diem project weren't about to just give up on the whole thing. Among them were Mo Shaikh and Avery Ching, who played pivotal roles in developing the Diem project, particularly in developing a crypto wallet called Novi Wallet.

![image40.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image40.png?raw=true)

They recognized the potential of the technology they had created, especially the Move programming language. Move, inspired by the Rust language, was created specifically for blockchain development and prioritized security and data verification to minimize potential errors and vulnerabilities.

![image17.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image17.png?raw=true)

Move's focus on safety wasn't just theoretical. It was born from real-world experience building Diem, where security flaws could have dire consequences in a financial context. Additionally, Move's design aimed to make it easier for developers to verify their smart contracts using Move Prover, adding another layer of protection and reliability to the applications built upon it.

Motivated by a desire to see their hard work realized, Shaikh, Ching, and others from the original Diem team founded Aptos Labs. This wasn't another rebranding exercise. It signified a focused evolution by building upon the core strengths of Diem. It also addressed the regulatory concerns and challenges that hampered Diem's success.

The Aptos mainnet officially launched on October 17, 2022.

![image6.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image6.png?raw=true)

The core motivations behind building the protocol can be distilled into these key points:

- **Scalability**: Aptos aims to handle significantly more transactions per second than older blockchains, positioning itself as a solution for large-scale adoption.
- **Developer Experience**: With Move and a focus on tooling, Aptos wants to make building decentralized applications a seamless and secure process.
- **User-Focused**: Recognizing that usability is key to mainstream blockchain usage, Aptos is prioritizing intuitive user interfaces and simplifying the complexities of the technology.

## **Funding the Vision**

Now, with great ideas comes greater funding. And if those ideas are carried by an experienced team, you might just raise a few hundred million dollars – even *before* launching your major product. Such was the case with Aptos. Even before their mainnet launch, Aptos Labs raised a massive $200 million in March 2022, followed by another $150 million in July of the same year. Investors like Andreessen Horowitz (a16z), FTX Ventures, and Coinbase Ventures backed Aptos early on. This kind of funding demonstrates the confidence investors had in the project and its potential to make a real impact in the blockchain space.

![image16.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/History%20of%20Aptos/image16.png?raw=true)

## Wrap Up

So, there you go folks... a comprehensive walk-through of the history of Aptos. From its roots in the Diem project to its reimagined vision, the Aptos story is one of resilience, innovation, and the relentless pursuit of a better blockchain. But this is just the beginning! In the coming sections, we'll take an even deeper dive into the world of Aptos, exploring its technology and empowering you to build amazing things on this exciting platform.

https://github.com/0xmetaschool/Learning-Projects/raw/main/Aptos%20C1%20Introduction%20to%20Aptos/1.%20Course%20Introduction/2.%20History%20of%20Aptos.md

History of Aptos

# What is Aptos?

Welcome back, my friend! Since you've chosen to dive into this course, you probably already know how quickly blockchain technology has skyrocketed. But have you ever stopped to think why it’s grown so fast, especially compared to other tech like the internet which took ages to catch on? It's pretty intriguing, right?

![image27.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20is%20Aptos/image27.png?raw=true)

As you can see blockchain as a technology is growing faster than the internet itself. Hence, it is considered a revolution in the tech industry.

The magic of blockchain starts with some key features you've probably heard about while googling around: decentralization and transparency. Impressive, huh? But what is the reason why blockchain is yet to be mainstream? One major challenge is speed and scalability. Many blockchains struggle to process transactions quickly and efficiently, which can limit their real-world use.

![image3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20is%20Aptos/image3.png?raw=true)

In an era where we might ditch a website just because it loads slowly, speed and cost become big barriers when it comes to adopting new tech.

What's the best fix for this? A blockchain that's quicker, cheaper, and can scale up….

## Enter Aptos: A Faster, More Scalable Blockchain!

![image18.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/What%20is%20Aptos/image18.png?raw=true)

Aptos is a highly scalable and secure layer-1 blockchain designed to enable the creation of decentralized applications using Move, a new smart contract language focused on security and safety.

Aptos tackles these limitations (speed and scalability) with its innovative features like **parallel execution, resource-oriented architecture, the Move language**, etc. I don’t want to spill the beans now, so let’s move on to the next lesson. We'll delve deeper into these features and how they work in the upcoming lessons.

## Wrap Up

We hope this lesson gives you a good snapshot of what Aptos is all about and the standout features it brings to the table. Next up, we’ll explore some of the popular dApps that have been built on Aptos. Stay tuned to see how developers are leveraging Aptos to create cool applications!

https://github.com/0xmetaschool/Learning-Projects/raw/main/Aptos%20C1%20Introduction%20to%20Aptos/1.%20Course%20Introduction/3.%20What%20is%20Aptos.md

What is Aptos?

# Important dApps on Aptos

Hey, there developers! If you are reading this then you already have read the origin of Aptos, went through the fundamentals of the protocol, and ended up here. In this lesson, we will be looking into some cool applications that are built on top of Aptos, so that you can get that much-needed inspiration to build some cool stuff on your own…

You see, a good number of useful applications is a sign of a healthy blockchain ecosystem and a large number of active users within those applications shows high adoption. The Aptos ecosystem has both a healthy number of applications and a high user count.

In this section, let’s just look at some of the star applications in the Aptos ecosystem and try to explore why they pretty much thrive thanks to Aptos.

![image26.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image26.gif?raw=true)

## DApps on Aptos

Now, for the blockchain to become this hub of super cool applications, it needs to enable certain things for the developers who build the application and users who use that application. In the case of Aptos, as we already discussed in the previous lesson, it comes with features like Move language support, parallel transaction execution, modular architecture, and a novel data model approach which enables the protocol to have higher scalability, security, and transaction processing capability.

All this leads to a better development experience for the developer and a rich user experience for the end user. This makes the protocol a suitable playground for a variety of applications that cover a wide range of use cases from deFi, social media, token exchanges, and even games and marketplaces.

Here are some of the most in-demand categories of applications from the Aptos ecosystem.

### DeFi (Decentralized Finance)

![image28.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image28.png?raw=true)

## Gaming

![image24.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image24.png?raw=true)

### NFT Tooling

![image35.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image35.png?raw=true)

### Tooling

![image19.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image19.png?raw=true)

### Marketplaces

![image34.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image34.png?raw=true)

### Social Media

![image29.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Important%20dApps%20on%20Aptos/image29.png?raw=true)

The Aptos scene is blowing up, not just with fresh new apps, but also with some OG web3 faves setting up camp. We're talking heavy hitters like PancakeSwap, the DEX everyone knows and loves, bringing their token-swapping magic to Aptos. Even Econia, a super cool hyper-parallelized on-chain order book, is building on Aptos. These big names are bringing their whole crew along, which could seriously fast-track how many people use Aptos.

## Call To Build On Aptos

So, at this point, we know exactly what you're feeling. Aptos boasts an exponentially expanding web3 ecosystem, with **over 150** kickass applications already live and kicking. Yet somehow you get this feeling the party is just getting started, and you want a front-row seat. Well, the most direct way to engage with the Aptos ecosystem and the community is to build your next moonshot idea on the Aptos platform. This would mean contributing to the growth of an ecosystem projected to reach **tens of millions of users** in the coming years, while also possibly developing the next big dApp that everyone in the community will be talking about.Now, If you're still on the fence about booting up your laptop and diving into building on Aptos, don't worry. As we progress through this course, we've dedicated a whole lesson to show you why building on Aptos could be the smartest move you make. In that lesson, we won’t just cover the exciting features that Aptos offers to its developers, we’ll also explore how you can tap into the generous grants that Aptos provides to developers like you, enabling you to develop and enhance your application. We'll delve deeper into that soon, so stay tuned!

## Wrap Up

Alright so, as you can see there are already some cool apps built on Aptos, but there's still plenty of room to create new ones.  Why not take a look at some more cool [applications](https://aptosfoundation.org/ecosystem/projects/all) that are already available out there and see if you can dream up something awesome to build on Aptos? Dive in and get those creative juices flowing!


https://github.com/0xmetaschool/Learning-Projects/raw/main/Aptos%20C1%20Introduction%20to%20Aptos/1.%20Course%20Introduction/4.%20Important%20dApps%20on%20Aptos.md

Important dApps on Aptos

# How Does Aptos Even Work?

Hey! Back for another round of Aptos knowledge?

Okay let’s do a quick recap, we've covered what Aptos is and what it's all about, but you might be wondering: how does this whole thing work?

This is where things get interesting. As developers, we naturally love diving into the nitty-gritty of how something is built. ️In this lesson, we're going to take a deep dive into the core workings of the Aptos platform.

Okay now buckle up! This lesson is going to be a bit detailed but hold tight as I will walk you through every detail with examples you can relate to.

## How Does Aptos Work?

We've been exploring what is Aptos, its history, etc, but you might be curious: what makes this tick?

![image7.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/%20How%20Does%20Aptos%20Even%20Work/image7.gif?raw=true)

Well, several crucial parts make the Aptos architecture so novel and innovative, We have so many reasons to build on Aptos and we know that we can’t walk you through all the parts here in this course but let’s dig deep into three fundamental parts of the Aptos blockchain…

1. Move language
2. Block-STM
3. Aptos Data Model

## Move Language

We have already read about Move language and its origin right? But you might be wondering what’s so special about it that blockchain like Aptos is using it to allow developers to build applications on top of it. Let’s delve into it…

![image17.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/%20How%20Does%20Aptos%20Even%20Work/image17.png?raw=true)

From what we have understood till now, one of the key ideas behind Move is to have a language that provides robust safety and security for handling digital assets like cryptocurrencies. It does this through a novel approach called resource-oriented design.

Okay, these might sound technical but let us break it down for you..

### Resource-Oriented Structure

You know how when you were a kid, you had that special binder for your Pokemon card collection? You couldn't just print out copies of the rare cards, they had to be the real deal. Well, Move treats digital assets kind of like those collectible Pokemon cards.

With Move, developers define custom "resource" types that represent scarce digital items like cryptocurrencies or NFTs.

And here's the cool part - the Move language itself enforces the scarcity rules, like the Pokemon cards and you keep these cards in those binder pockets, one card in one pocket. You can't just make unlimited copies, because Move codes those scarcity rules into the resource types. Here the binder pockets are the resources storage where you store your resources.

In short “resources” in Move are custom types that can never be copied or implicitly discarded.

### Enhanced Security

Imagine you're going on a road trip and packing for the first time. You want to make sure you bring all the essentials and nothing gets lost or stolen along the way. What do you do?

For regular programming languages, it's like using a duffel bag. You can stuff all your things in there, but it's easy for items to go missing or for someone to reach in and take things without you noticing. Not very secure!

Move is like using one of those fancy, locked suitcases specifically designed for secure travel. It has a few key security features:

- A lock with a combination code that only you know. This is like Move's "formal verifiability" - it uses advanced logic to mathematically prove your digital assets are packaged up correctly.
- Reinforced corners and zippers to prevent break-ins. That's similar to Move's built-in protections against common security attacks like re-entrancy exploits.
- Careful organization with segmented compartments for different items. In Move, resource types enforce clear ownership to make sure every resource has only a single owner.

Well, that’s it about the Move language, it is time to move on to learn about Block-STM, we are already so excited to talk about it as this is considered to be one of the few technologies in the blockchain industry that enable parallel transactions in blockchains. Okay, that’s enough for now let us walk you through how awesome this tech is..

## Block-STM

Remember our discussion about building applications on Aptos? It's like running a busy grocery store. You want to serve customers (process transactions) quickly and efficiently, especially during peak hours. But what if, during these rush times, the checkout line gets so long that customers get frustrated and even abandon their carts (transactions)? This can happen on some blockchains where transactions are processed one by one, leading to high gas fees during peak usage. Block-STM acts as your secret weapon for handling these checkout line nightmares.

Okay, I know this might sound a little overwhelming so let’s start from the beginning, why this tech is needed in the first place?

### The Challenge: Single Lane, Long Wait

Imagine stores having one cashier processing customers one by one (sequential processing). This can lead to long lines and frustrated customers, especially when everyone wants to check out at the same time. (This is similar to how transactions are processed on some blockchains). In layman's terms, this is how blockchains like Ethereum process their transactions, so during peak hours, all the transactions get queued up as the transactions are processed one by another and thus the gas fees go crazyyy high!

![image14.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/%20How%20Does%20Aptos%20Even%20Work/image14.gif?raw=true)

### Block-STM to the Rescue: Multiple Checkout Lanes

Block-STM is like having multiple cashiers working simultaneously (parallel processing within a block). Customers can get in different lines and be served concurrently, significantly reducing wait times. This is how Aptos processes the transactions in parallel!

### But Wait, What’s the Catch?

Not all groceries (Blockchain Data) are the same. Some might require more scanning or bagging (complex transactions). Block-STM is smart – it can group similar items (identify dependencies) and send them to the most appropriate cashier (optimize scheduling). This ensures even large orders are processed efficiently.

Next, let’s move to understanding the data model and learn the difference between the traditional data model and Aptos data model.

### Traditional Data Model: The Messy Garage

Imagine showing your friend around your garage where you keep all your car stuff, but it's a total mess:

- Engine tools are buried under piles of old newspapers.
- Paint codes are on a sticky note somewhere under a stack of pizza boxes.
- Wheels are just rolling around the floor.
- Gadgets and wires are stuffed into any drawer with space.

You might chuckle and say, "It's a disaster, right? Every time I need something, I have to dig through all this. It takes forever, and half the time, I end up just buying new stuff because I can't find the old" lol.

![image15.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/%20How%20Does%20Aptos%20Even%20Work/image15.gif?raw=true)

This chaos is what dealing with the traditional data model used to be like. Everything was everywhere—your data and resources were scattered across your account storage. It was hard to find and manage because:

- Important things were hidden in places you wouldn't think to look.
- You had to sort through everything just to find one thing, which was slow and frustrating.

### Aptos Object Model: The Neat Toolbox

Now, imagine you decide to completely overhaul your garage into a neat, organized space equipped with a state-of-the-art toolbox:

**Definition of Aptos Object Model:**

The Aptos Object Model is an advanced organizational system for blockchain data. It prioritizes organization and security by grouping related resources into single addresses. Think of it like a well-organized toolbox – everything has its designated spot, wrenches with wrenches, screwdrivers together. Similarly, the Aptos Object Model keeps your blockchain data neatly organized in one place. This approach unlocks several key benefits:

- **Simplified Management:** Data is grouped logically, making complex information like tokens or NFTs a breeze to access and manage. No more hunting around for specific data points scattered across the blockchain.
- **Fine-Grained Control:** Security gets a boost! You have granular control over who sees or interacts with specific data elements within an object this is similar to access control in Solidity. Think of it like assigning permissions for different tools in your toolbox – only authorized users get to touch the fancy screwdriver set.
    
![image4.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/%20How%20Does%20Aptos%20Even%20Work/image4.png?raw=true)
    

With the Aptos object model, managing blockchain resources is as straightforward as finding a tool in a well-organized toolbox. It makes everything easier, from everyday tasks to keeping everything secure and up-to-date. This model is all about making your life easier, just like a tidy garage does.

And that’s it…congratulations you have been amazing till now and we know this lesson was information savvy so we will be continuing with Aptos Assets standards in the next lesson!

## Wrap Up

The lesson gives a snapshot of Aptos's core principles: strong validators, fast transactions with Move, and smooth transaction management. It also explains how transactions work on Aptos, ensuring security and efficiency. Overall, it shows why Aptos is a solid choice for blockchain development.

By now, we believe that you have a really good understanding of how Aptos works under the hood and how different features of Aptos help it gain all that crazy speed, security, and performance.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C1%20Introduction%20to%20Aptos/2.%20Understanding%20Aptos%20Architecture/1.%20How%20Does%20Aptos%20Even%20Work%3F.md

How Does Aptos Even Work?

# Aptos Asset Standards

Hi Folks! The rise of blockchain technology has brought with it an array of digital tokens, each with its unique properties and applications. Two prominent categories of these tokens are **fungible** and **non-fungible** tokens.

Aptos used to rely on the “Aptos Coin standard” for fungible tokens and “Aptos Token” for NFTs But both of these standards used the Account resources data model for their implementation. In August 2023, Aptos introduced two new standards after a vote on Aptos Improvement Proposal-21 in July 2023.

![image13.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Aptos%20Asset%20Standards/image13.png?raw=true)

Hence these two new standards were brought into effect.

1. **Aptos Fungible Asset Standard** for regular tokens, tokenized real-world assets, and in-game assets
2. **Aptos Digital Asset Standard** for NFTs

The new token standards would use Move’s object model, Yeah the same model we just talked about in the previous lesson. Deriving fungible assets out of objects allows for both a seamless developer experience but also simplifies application development time. Treating assets as objects allows developers to write all sorts of custom properties for them and save them as resources. Let’s understand these two standards briefly.

### **Aptos Fungible Asset Standard**

The new Aptos Fungible Asset Standard is a standard meant for simple, type-safe, and fungible assets based on an object model intending to replace the Aptos coin (legacy). So all the resources defined here are included in the object resource group and stored inside objects. There are two types of objects related to FA:

- Object<Metadata>: include information about the FA, such as name, symbol, and decimals.
- Object<FungibleStore>: store a specific amount of FA units. FAs are units that are interchangeable with others of the same metadata.

The different objects involved - Object<Metadata> and Object<FungibleStore> objects, and their relationships to accounts are shown in the diagram below:

![image2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Aptos%20Asset%20Standards/image2.png?raw=true)

We already discussed the fact that Metadata stores key details about the fungible asset, such as name, symbol, decimals, and other descriptive attributes and Fungible store is responsible for storing a specific amount of FA.

Each FungibleStore object has an owner. However, an owner may possess more than one store. Let’s say Alice wants to send some FA to Bob, how does she determine the correct destination? Additionally, what happens if Bob doesn't have a store yet?

To address these questions, the standard has been expanded to define primary and secondary stores.

1. **Primary Fungible Store**

The Primary Fungible Store is responsible for the main storage responsible for core functionalities of the fungible asset. It references Metadata for asset details and is linked to Alice as the owner, enabling her to perform operations like transferring tokens, minting, or burning.

- Each account owns **only one non-deletable** primary store per FA type.
- The address is derived deterministically from the account address and metadata object address using the sha256 hash function.
- If a primary store does not exist, it is created automatically when FA is deposited.
1. **Secondary Fungible Store**

The Secondary Fungible Store manages additional functionalities beyond basic asset management. It references Metadata for consistency in asset details and is linked to Alice as the owner, allowing her to use extended functionalities for complex scenarios like DeFi etc.

- Accounts can have multiple secondary stores.
- Addresses are non-deterministic, offering flexibility but requiring extra management effort.
- Secondary stores are theoretically deletable.

The Owner, Alice owns and controls both the Primary and Secondary Fungible Stores, conducting operations like sending and receiving tokens, and managing secondary stores for advanced use cases. We will be learning the implementation and in-depth usage of this standard in the upcoming courses. You just need to get familiar with the standards for the time being.

### Aptos Digital Asset Standard

An NFT is a non-fungible token or data stored on a blockchain that uniquely defines ownership of an asset. NFTs are typically defined using the following properties:

- name: The name of the asset. It must be unique within a collection.
- description: The description of the asset.
- uri: A URL pointer to off-chain for more information about the asset. The asset could be media such as an image or video or more metadata.
- supply: The total number of units of this NFT. Many NFTs have only a single supply, while those that have more than one are referred to as editions.
    
![image22.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Aptos%20Asset%20Standards/image22.gif?raw=true)
    

Each NFT belongs to a specific collection, acting as a container for related tokens. Now, consider this: A collection is an object with its own address and various resources, just like each token within a collection. That's right: every Collection and NFT on the Aptos blockchain has its own unique address, allowing you to manipulate them individually and add properties as needed.

Each collection has a similar set of attributes:

- name: The name of the collection. The name must be unique within the creator's account.
- description: The description of the collection.
- uri: A URL pointer to off-chain for more information about the asset. The asset could be media such as an image or video or more metadata.
- supply: The total number of NFTs in this collection.
- maximum: The maximum number of NFTs that this collection can have. If the maximum is set to 0, then the supply is not tracked.

The new Aptos Digital Asset Standard allows:

- Rich, flexible assets and collectibles.
- Easy enhancement of base functionality to provide richer custom functionalities.

Digital Asset (DA) is also recommended for any new collections or protocols that want to build NFT or semi-fungible tokens. We’ll suggest that you check out [Topaz.so - Aptos NFT Marketplace](https://www.topaz.so/) .

### That’s a wrap

So in summary, Aptos has introduced new token standards: the Aptos Fungible Asset Standard and Aptos Digital Asset Standard. These standards leverage Move's object model for seamless development and simplified applications. Each NFT and collection now has a unique address on the Aptos blockchain for individual manipulation. We’ll see you in the next lesson.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C1%20Introduction%20to%20Aptos/2.%20Understanding%20Aptos%20Architecture/2.%20Aptos%20Asset%20Standards.md

Aptos Asset Standards

# Aptos vs Non-Move-Based Chains

Hey, let's dive into what makes Aptos stand out from the crowd in the world of blockchain! Trust me, understanding this will help you see why Aptos is the one you’d wanna work with.

If you want to size up something in the blockchain world, you've got to stack it against the best, right? And in this arena, EVM chains stand tall as the benchmark of excellence, yeah I know due to gas fees it’s hard to scale your apps on top of EVM chains but we need to understand that these blockchains have been battle-tested over time. Let's seize this opportunity to compare Aptos and Non-Move-based chains. We will be comparing these three juggernauts on these parameters.

![image41.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Aptos%20vs%20Non-Move-Based%20Chains/image41.png?raw=true)

## Transaction Speed

![image20.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Aptos%20vs%20Non-Move-Based%20Chains/image20.png?raw=true)

Aptos completely obliterates EVM chains like Ethereum and Non-Move-based chains like Solana when it comes to transaction speed. Let’s take an example of Ethereum which may not be strictly single-threaded, its core transaction processing for block validation happens sequentially. This means transactions are processed one after another, limiting its overall throughput.

Aptos on the other hand, utilizes its AptosBFT (the consensus protocol) and Block-STM (Software Transactional Memory) for parallel transaction processing. Block-STM allows validated transactions within a block to be executed simultaneously on all 16 cores, significantly accelerating transaction speed. We will talk about Block-STM in the coming lessons so don’t worry!

EVM chains like Ethereum can handle around **15 transactions per second (TPS)**, and Binance can handle around **55 - 60** **transactions per second (TPS)** whereas Aptos can handle over **150,000 transactions per second (TPS).** When it comes to transaction confirmation time, Aptos takes less than a second whereas EVM chains can go up to 5 minutes.

Now, let’s take a look at another non-Moved-based chain, Solana, it can handle around **65000 transactions per second (TPS)** whereas as we already mentioned Aptos can handle over 150,000 transactions per second (TPS). Also, Solana takes 3 - 4 seconds whereas Aptos takes less than a second to process the transaction.

## Stability and Reliability

EVM chains have been around since 2015 and have a proven track record of stability. It has survived multiple network upgrades and has never suffered a major security breach. It is secured by a vast network of miners, making it highly resistant to attacks. However, its high usage and limited scalability can cause EVM chains like Ethereum to become congested.

Aptos is a newer blockchain specifically designed for high transaction throughput and low latency. When it comes to raw transaction speed and efficiency, AptosBFT shows potential advantages over the EVM chain’s PoS. Aptos is a relatively new blockchain with a limited track record, it shows a lot of promise but the EVM chain is well-known in terms of stability due to its long history and battle-tested network.

## User Experience and Fees

EVM chain's dominance comes with a price - slow transaction times and high fees can frustrate users. Sometimes the fee itself can be more than the transaction value so scalability is frowned upon due to the high gas fees.

Aptos, on the other hand, is built for speed and scalability. This translates to potentially much faster transactions and significantly lower fees compared to a congested EVM chain. While Aptos is a new player with a developing ecosystem, it offers an exciting glimpse into a future where blockchain interactions are faster, smoother, and more affordable.

## Wrap Up

Aptos sets itself apart with its impressive transaction speeds, innovative design, and user-focused approach. While competing with established platforms, Aptos demonstrates good reliability and efficiency. Its advanced hardware and fail-proof architecture position Aptos as a promising contender in the evolving blockchain landscape.

Next up, we will go through the advantages of Aptos and how it can make you stand out from the crowd.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C1%20Introduction%20to%20Aptos/2.%20Understanding%20Aptos%20Architecture/3.%20Aptos%20vs%20Non-Move-Based%20Chains.md

Aptos vs Non-Move-Based Chains

# Advantages of building on Aptos

Alright, by now we've covered pretty much everything there is to know about Aptos and its inner workings. Now comes the big question: What's in it for you as developers? What are the benefits, advantages, and bonuses that come with building cool applications on Aptos?

![image32.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image32.gif?raw=true)

## Reasons for Building on Aptos

Without further ado, let's see the reasons to build on Aptos…

### Aptos Handles a Lot of Transactions Quickly

![image39.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image39.gif?raw=true)

Aptos is known for being a very fast blockchain, capable of handling numerous transactions at the same time. This is possible because of a technique called parallel execution, where Aptos processes many transactions simultaneously, but only if they don't conflict with each other. This method is much faster than processing transactions one after another.

### Aptos Keeps Everything Secure With Move

![image23.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image23.gif?raw=true)

Aptos uses a programming language called Move, and it’s kind of like a superhero of coding languages when it comes to safety and security. Move comes packed with features that help it automatically spot any sneaky or harmful smart contracts trying to stir up trouble. It’s like the developer can’t write bad codes, the compiler will always throw errors until every single error is fixed even the logical ones!

Another cool tool in Move’s belt is something called formal verification. This is basically using some serious math to double-check that everything a program is supposed to do is spot on, without any errors.

So, by using Move, Aptos is focusing on keeping things secure. It’s like having a really good security system in place to make sure everything runs smoothly and safely.

### Aptos Allows Easy Upgradability and On-Chain Governance

![image38.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image38.gif?raw=true)

Aptos is built with a cool modular architecture, which means it’s super flexible and easy to upgrade. This setup helps users keep up with the ever-changing Web3 world more smoothly, without much hassle or downtime.

What’s more, Aptos takes upgrading to the next level with its on-chain governance system. This system lets people who hold tokens have a say in protocol upgrades through voting.

It's like having a say in how your favorite online platform evolves, which is something we’ve always wanted in Web3, right? Aptos delivers on that front, making it easier for everyone to stay up-to-date and secure.

### Aptos Provides Tons of Tools and Resources for Its Developers

![image5.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image5.gif?raw=true)

Aptos rolls out the red carpet for developers with its impressive set of tools and resources. Whether you’re looking to whip up some smart contracts or craft your very own decentralized app (dApp), Aptos has got you covered with everything you need to make the process smooth and straightforward.

Here's a peek at some of the cool tools developers get to play with:

- SDK: This toolkit is your golden ticket to building stuff that works with the Aptos platform. You can dive into more details [here](https://aptos.dev/sdks/index/).
- Interactive REST API: Need specifics on how to interact with the Aptos network? Check out the detailed API docs [right here](https://aptos.dev/nodes/aptos-api-spec/#/).

And don't sweat it if you're just starting —this course is designed to level up your skills from newbie to pro in no time.

### Aptos Has a Pretty Strong Community and Ecosystem Support

Whatever type of support you need while building on Aptos, they've got your back.

![image10.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image10.gif?raw=true)

Aptos puts community and ecosystem support at the center of everything they do. They offer loads of ways for developers and tech enthusiasts to get together, share ideas, and help each other out.

If you’re new around here, they’re super welcoming and encourage you to jump into discussions across several platforms like:

- [Discord](https://discord.gg/aptosnetwork): Jump in and chat with other Aptos builders.
- [Aptos Dev Discussions](https://github.com/aptos-labs/aptos-developer-discussions/discussions): Dive into more technical talks and share your development experiences.
- [Forum](https://forum.aptosfoundation.org/): Explore more structured discussions on various topics.
- [Medium](https://medium.com/aptoslabs): Check out their latest articles and updates.
- [Telegram](https://t.me/AptosTG): Get quick updates and engage with the community.
- [Twitter](https://twitter.com/Aptos): Follow for all the latest tweets and info.

And hey, if you ever get stuck or just have a question, feel free to ask. Remember, we at Metaschool are also here to help you out with anything you find confusing about Aptos.

Plus, the Aptos Ecosystem Projects showcase a wide variety of live projects, from DeFi and NFTs to gaming and marketplaces. If you're keen to dive in, the [Community list](https://aptos.dev/community/) is your gateway to contribute through things like updating documentation or tweaking code.

So, why not join the Aptos community today? It’s a place buzzing with collaboration and innovation!

## Real-World Use Cases and Adoption

Aptos is basically a huge toolkit that gives developers everything they need to make scalable and sustainable applications. Already, there are 138 projects built on Aptos, which dives into everything from finance and gaming to digital art and social media.

Now, let’s just take a moment and analyze why Aptos works so well across such a diverse range of use cases.

### Gaming

![image37.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image37.gif?raw=true)

Imagine Aptos as a turbo boost for game developers. It brings together lightning-fast transaction speeds, ironclad security, and seamless interoperability. What does that mean for gamers? More immersive and responsive gaming experiences where you can truly own and trade your game assets freely. Curious to see how games are evolving on Aptos? Check out some cutting-edge gaming projects [here](https://aptosfoundation.org/ecosystem/projects/gaming).

### NFTs

![image33.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image33.gif?raw=true)

Dive into the vibrant world of NFTs on Aptos, where creativity knows no bounds. Collections like Overmind, Bruh Bears, and MAVRIK aren’t just digital art; they’re redefining artistic expression in the digital age, offering unique, owner-controlled experiences. Ready to explore the frontier of digital artistry? Take a peek at these imaginative collections [here](https://aptosfoundation.org/ecosystem/projects/nft-tooling).

### DeFi

![image25.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image25.gif?raw=true)

Aptos makes sure your money gets where it needs to go, whether you’re sending cash to family, lending to a buddy, or buying something cool. Thanks to partnerships like the one with Mastercard Crypto Credential, Aptos is boosting transaction speed, safety, and transparency. Check out active DeFi projects on Aptos [here](https://aptosfoundation.org/ecosystem/projects/defi).

### Social Media Platforms

![image8.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image8.gif?raw=true)

Aptos is reimagining the social media landscape, putting control and ownership of content back into the hands of users. Platforms like Chingari are not just growing; they are setting new standards for on-chain social interactions with rapid scalability and enhanced user privacy. Want to see how social media is evolving on the blockchain? Discover more about these pioneering projects [here](https://aptosfoundation.org/ecosystem/projects/social).

## Grants For Grabs

Now, we know you're probably already powering up your laptops to dive into your Aptos developer journey, but hold on a second—there’s something that’ll make this even sweeter! Let’s Talk about the Aptos Grant Program.

This program is a real game-changer, this program has already given out over $23.5 million in non-dilutive grants. That means you can secure the funding you need without sacrificing any ownership of your project. It's ideal for anyone bursting with big ideas for blockchain innovations eager to make a splash on the Aptos network.

![image1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C1%20Introduction%20to%20Aptos/Advantages%20of%20building%20on%20Aptos/image1.png?raw=true)

Feeling stuck for ideas? No worries! The grant program has some suggestions like building developer tools, creating DeFi applications, or launching educational initiatives. They’re open to any project that adds some fresh value to the Aptos ecosystem.

Now, Here's the scoop on what you need to nail the whole grant thing :

- **Big Impact:** Your project should be something that makes people go, "Wow!"—pushing limits and delivering real value.
- **Open Source Promise:** Down the line, your project should be available for everyone to use and build upon.
- **Solid Plan:** Whip up a detailed proposal that shows off your project, your team, and how you’re going to tackle any potential challenges.

Interested? Jump over to the [Aptos Foundation website](https://aptosfoundation.org/grants#guidelines), learn more about how to apply, and grab those grants!

## Wrap Up

Alright folks, there you have it! We've shared some pretty compelling reasons why Aptos should be your top pick for building out your next project. But trust us when we say, we’re just getting warmed up. Aptos is bursting with innovative features and robust resources that supercharge your ability to create something truly amazing.

So, if you’re stoked about diving into a platform that’s all about pushing boundaries and making your development journey smoother and more thrilling, then you've got to give Aptos a closer look. Dreaming of crafting the next blockbuster game, a cutting-edge DeFi platform, or a groundbreaking social media app? Well, Aptos is where your ideas can soar. Ready to jump in and discover where Aptos can take your projects? Let’s make it happen with Metaschool!



https://github.com/0xmetaschool/Learning-Projects/raw/main/Aptos%20C1%20Introduction%20to%20Aptos/2.%20Understanding%20Aptos%20Architecture/4.%20Advantages%20of%20building%20on%20Aptos.md

Advantages of Building on Aptos

# Lesson 9: Let’s Wrap Up the Course

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. I am super excited for all of you since you all have decided to start with Aptos and here we are completing our very first course together.

## Understanding of the Aptos Platform

You gained a basic knowledge of the Aptos platform. You understood the history of Aptos works, what dApps are built on it, and how it is leading the blockchain world after comparing it with other blockchains. Let us recall what we learned about Aptos.

Aptos is a Layer-1 blockchain. It is built specifically keeping scalability, safety, reliability, and upgradeability in mind. Aptos introduces innovations in consensus, smart contracts, security, performance, and decentralization.

## Dope Stuff on Aptos

You explored what developers are building on the Aptos platform, what applications are already built on it, and what you can also build. You explored how grants can support Aptos developers by delving into the world of Aptos.

## Understanding of Aptos Architecture

You gained in-depth knowledge of how Aptos works. You learned about Aptos's:

- Parallel execution model and data partitioning
- Transaction lifecycle and processing
- Consensus protocol and Byzantine fault tolerance
- Modular architecture (consensus, execution, storage)
- Resource model and Move integration

## ⚒️ A Small yet Important Request

Here is 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/stacks-course) and [LinkedIn](https://bit.ly/stacks-course-linkedin) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos. ✨

## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

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

Let’s Wrap Up the Course

Introduction to Aptos Platform

This course has been carefully designed to help you use your knowledge from the introductory course and get to building on Aptos. This course will equip you with the basics of the Move programming language, essential to develop on Aptos, and help you deploy your first smart contract on Aptos Move, along with understanding the structure of the language and the smart contract. You will also learn about the variables, constants, data types, operators, functions, structs, resources, and control flow in Move. The final assignment of this course is to build a project in Move implementing all that you have learned in the course.

# What Are We Building Today?

GM everyone! ☀️ We’re super excited to kick off the second course in our detailed series on Aptos for developers here on Metaschool. First things first, let’s give you a big round of applause for completing the [first course on Aptos](https://metaschool.so/courses/introduction-to-aptos-chainn). Woohoo! 🎉

Did you know? Engaging with blockchain projects on GitHub can lead to unexpected perks. Aptos, like many others, often rewards its most active followers. Consider following [their repo](https://github.com/aptos-labs) to stay in the loop!

![image62.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/What%20Are%20We%20Building%20Today/image62.webp?raw=true)

Aptos is a powerhouse layer-1 blockchain with nearly $400 million in funding and a market cap approaching $4 billion. With daily transactions averaging 500K, Aptos is the place to be! We're thrilled to help you build on this platform and bring your dApp ideas to life, with the chance to win grants for innovative projects. It's time to put your ideas to the test—literally!

We have already talked about features like the Resource-oriented structure, Block STM, Aptos Standards, and the Move programming language in our first course. Instead of long-winded articles, we’re going hands-on this time—because the best way to learn is to get building, right? This course ensures you pick up practical skills and confidence, starting with a basic calculator dApp. As you progress, you’ll learn new concepts and add more functionalities to your dApp.

## The Calculator dApp

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

- **Hands-on Learning:** Building a calculator dApp is an engaging and practical way to grasp Aptos blockchain concepts like **smart contracts**, which are self-executing programs that power dApps.
- **Move Fundamentals:** You'll delve into **Move on Aptos**, the programming language specifically designed for creating smart contracts on Aptos. By building the calculator, you'll gain a strong foundation in Move on Aptos syntax and functionality.
- **Deployment and Interaction:** The excitement doesn't stop at coding! You'll deploy your calculator dApp onto a blockchain, allowing you to interact with it and see your code come to life in a decentralized environment.

You can try it out yourself [here](https://calculator-d-app.vercel.app/).

### Features of dApp

This course will equip you with the knowledge and skills to build the **core functionalities** of a calculator dApp:

- **Basic Arithmetic Operations:** You'll master adding, subtracting, multiplying, and dividing numbers using smart contracts.
- **Advanced Features:** We'll explore functions like calculating powers, performing modulo operations (finding remainders), and implementing logical and comparison operations for a versatile calculator.

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

## Course Overview

We will:

1. Quick run through through the history of Aptos
2. Dive into what makes Aptos Move stand out.
3. Get your tools and workspace ready for development.
4. Launch your first smart contract on Aptos and see it in action.
5. Enhance Your Calculator dApp with Key Concepts of Aptos Move:
    1. Structs and resources
    2. Variables and constants
    3. Functions
    4. Operators
    5. Loops
    6. Advanced concepts like abilities, and visibility specifiers in Move
6. Deploy and Interact with the Calculator dApp on Testnet

## Who exactly should take this course?

This course is for beginner Web3 developers who wish to learn about Aptos and have completed our first introductory course on Aptos. 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?

As a developer, you will be getting the following outcomes when you complete this course:

1. Learn Move to build on Aptos
2. Build dApps on Aptos
3. Claim your NFT upon course completion

## Proof of completion

If you complete this course with me, 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.

![image50.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/What%20Are%20We%20Building%20Today/proof-of-completion-ezgif.com-optimize.webp?raw=true)

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

1. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [Github](https://github.com/0xmetaschool/), it would be a great support. 🫣
4. Stay happy and positive!

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


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/1.%20Introduction%20to%20Build%20on%20Aptos/1.%20What%20Are%20We%20Building%20Today.md

# Journey Into the Basics

Alrighty, folks! Buckle up because we’re laying the groundwork for our adventure into the world of blockchain magic! 🌟 In this lesson, we’re diving deep into the basics of blockchain, and smart contracts, and getting a sneak peek into the awesome world of the Move language. Get ready to build your knowledge from the ground up!

## WTH is blockchain?

Alright, let’s dive into the legendary tale of banks—the classic example that unveils the wonders of blockchain to all newbies stepping into the realm of web3 magic! 💫 Picture this: You trust the bank with your hard-earned cash, believing they'll keep it safe and let you access it whenever you need it. But what if the bank suddenly decides to play hide-and-seek with your money? Sounds scary, right? Well, in the centralized world of banking, it's a risk we take.


But fear not, brave souls! Here’s where our hero swoops in with a cape and a drumroll... 🥁 Enter Blockchain!

So, what's the deal with blockchain? You might've heard it's a decentralized digital ledger, but let’s unravel that lingo! Imagine traditional banks as notebooks guarded by a single master. Only they can write or tweak what's inside. Now, shift gears to blockchain—it's like a treasure trove of notebooks, each guarded by a squad of guardians. They can peek inside, and verify, but no one holds the ultimate power. It’s like a team effort where everyone has a say!

But wait, there's more! Blockchain boasts immutability—once it's on the ledger, it's there to stay, no tampering allowed! Plus, it flaunts transparency, meaning you can peek into transactions whenever you want. It's like the ultimate truth-teller of the digital world!

![Blockchain-ezgif com-resize](https://github.com/0xmetaschool/Learning-Projects/assets/130544719/4e242645-f83e-4a91-af24-ec903446e6c7)

## WTH are Smart Contracts?

Alright, now that we've dipped our toes into the magical waters of blockchain, let's dive a little deeper, shall we? We've all heard of the blockchain power duo—Bitcoin and Ethereum. Bitcoin paved the way for blockchain as a decentralized currency exchange, but then along came Ethereum with a game-changer: Smart Contracts!

![image5.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Journey%20Into%20the%20Basics/image5.webp?raw=true)

Imagine this: You write a piece of code, pop it onto the blockchain, and bam! It becomes an unstoppable force, executing itself when certain conditions are met. That's the beauty of a Smart Contract—it's like magic, but for real! ✨ And guess what? One of the VIP languages for these contracts is called Solidity.

Now, you might be thinking, "Hold on a sec, weren't we supposed to be talking about Move programming language?" You're absolutely right! Move is our shining knight in blockchain armor! While Solidity has had its fair share of uh-oh moments with hacks, Move swoops in with a promise of security and safety. So, buckle up, because we're about to take a whirlwind tour of Move—your new favorite programming language!

## Into the world of Move programming language

Get ready to dive into the fascinating world of Move—your ticket to building secure, reliable, and downright awesome smart contracts!

### Key features of Move

- **Safety First:** Move prioritizes safety by employing static typing and a resource-oriented approach. This ensures memory safety and prevents common vulnerabilities in smart contract code.
- **Focus on Resources:** Move treats digital assets (like currency) as special resource types. This allows for strict control over ownership and transfer of these assets on the blockchain.
- **Bytecode Language:** Move compiles to bytecode, which is directly executed by the blockchain. This streamlined approach enhances efficiency and security.
- **Modular Design:** Move uses modules to promote code reusability and improve code organization for complex smart contracts.

## That’s a wrap

Whew! We've got the basics down pat, and now it's time to crank up the excitement even more! 🚀 In our next lesson, get ready to dive deeper into the awesome world of Move language and discover why it's the ultimate choice for crafting jaw-dropping dApps. Can't wait to see you there!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/1.%20Introduction%20to%20Build%20on%20Aptos/2.%20Journey%20Into%20the%20Basics.md

Journey Into the Basics

# Why use Move to Build dApps

Welcome back! 🌟 There’s a quote that goes, “If you just communicate, you can get by. But if you communicate skillfully, you can work miracles.” To build our dApp, we need to be able to “communicate” with the Aptos Blockchain to store data and perform the necessary operations required for our Calculator to work some magic.

Just like how we’re using English, a spoken language, to communicate with you right now, we will use a programming language called Aptos Move to communicate with the Aptos Blockchain.

## Move it or Lose it: Why Move?

We had already talked about Move in brief in the previous lesson but let’s dive a bit deeper and understand the motivation behind the creation of Move and the purposes it serves.

Born from Facebook's Diem project and based on the Rust programming language, Move is adaptable and perfect for building dApps. Aptos Labs adopted Move and optimized it for their blockchain, focusing on dialects and functionalities specific to the Aptos environment. Despite these optimizations, Aptos Move remains highly similar to core Move (around 70-80%), making the transition smooth for existing Move developers.

![image56.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Why%20use%20Move%20to%20build%20dApps/image56.webp?raw=true)

## What was the need for Move?

In one word: Security. Since 2020, the web3 ecosystem has lost nearly $8 billion to hacks and attacks. Move is designed to prevent common security flaws like reentrancy attacks and integer overflows, which are prevalent in other smart contract languages.

![image30.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Why%20use%20Move%20to%20build%20dApps/image30.webp?raw=true)

For more on the intensity and frequency of these hacks, visit [rekt.news](https://rekt.news/).

## Making dApps Move: Secure & Reliable by Design

When building decentralized apps (dApps), security and reliability are crucial. No one wants their app to be hacked or lose trust because of bugs. Aptos Move helps prevent these issues through several key features.

![image51.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Why%20use%20Move%20to%20build%20dApps/image51.webp?raw=true)

### 1. Resource-centric Design

Smart contracts handle digital assets on the blockchain. Move takes a different approach, focusing on the assets themselves with a resource-based design. This means your assets are stored directly in your account, giving you complete control. Unlike Solidity, where smart contracts act as middlemen between you and your assets, Move ensures you own the assets directly.

### 2. Enforced Scarcity

Move enforces scarcity on resources, meaning you can control the number of resources created and prevent accidental creation or duplication. This is crucial for maintaining the value of assets, just like how the rarity of a coin is preserved by limiting its quantity.

### 3. Granular Access Control

Move allows precise control over who can interact with and modify resources within a smart contract. Similar to how you might give different levels of access to people handling your coin collection, Move lets you specify who can do what with your resources.

### 4. Formal Verification

Move includes a tool called the Move Prover, which checks if your smart contract works according to specified rules. This is like an in-built testing feature that ensures the safety and security of your contract by verifying its behavior.

## That's a wrap

To sum up, we explored how Aptos Move enhances dApp development with its focus on security, verifiability, and resource management. We saw how it prevents common security issues, keeps digital assets at the forefront, enforces scarcity, allows granular access control, and includes tools for formal verification. In the next lesson, we’ll get hands-on by setting up the Aptos SDK to start building our calculator dApp on the Aptos blockchain. See you soon.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/1.%20Introduction%20to%20Build%20on%20Aptos/3.%20Why%20use%20Move%20to%20build%20dApps.md

Why Use Move to Build dApps

# Set Up the Environment Wizard

Hey there, welcome back! You've been crushing it so far, grasping why Move is so incredible! Now, it's time to take the next step and set up our development environment with all the necessary dependencies.

You might be wondering, "Why do we need to do all this?" Well, to build our dApp, we need the right tools in place. This will allow us to code, run, deploy, and ultimately interact with our creation. So, let’s dive into this lesson, get everything set up, and get ready to build our awesome dApp!

## Understanding dev wizard

Alright, now that we've nailed down the basics of smart contracts and blockchains, let's dive into where all the magic happens—the development environment! Think of it as your personal coding workshop, filled with the essential tools needed to bring your software creations to life. For our project, the Calculator dApp, there are a couple of must-have tools: a code editor and a compiler.

![image52.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image52.webp?raw=true)

The code editor helps you organize your code, while the compiler converts your code into bytecode—a special language that your computer, or more specifically, the blockchain, can understand. So, let's get these tools set up! We'll be installing:

- [**VS Code**](https://code.visualstudio.com/download): An Integrated Development Environment (IDE) and code editor that will make your coding experience a breeze.
- [**Move Analyzer**](https://marketplace.visualstudio.com/items?itemName=move.move-analyzer): This extension provides essential language support for the Move programming language. While it's technically optional, we highly recommend installing it to enhance your coding experience.

We'll also be building a front-end for our dApp, so you'll need a couple more tools on your system. Make sure to install the following:

- [**Git**](https://www.git-scm.com/downloads): Essential for version control and managing your codebase.
- [**Node and npm**](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm): Vital for running JavaScript code and managing packages.
- **Git CLI:** It allows you 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.
    ![Screen Recording 2024-07-15 at 11 44 49 AM](https://github.com/user-attachments/assets/6c039326-e3c3-4823-b210-176cd1ad09c6)

Get these installed, and you'll be all set to create an awesome front-end for our Calculator dApp!

## Environments in the blockchain network

Alright, buckle up for a little journey into a crucial concept when diving into the blockchain world—exploring the different environments where the magic happens! Aptos blockchain offers a buffet of options: mainnet, devnet, and testnet.

- **Devnet**: Your local playground for lightning-fast testing & development.
- **Testnet**: It's like a mirror of the mainnet, perfect for realistic testing. Plus, it hands out "play" tokens, so you can deploy and test your code without spending real dough. Just hit up the faucet to get your hands on these tokens for free!
- **Mainnet**: The real deal. It's where the big leagues play, with actual tokens and real-world impact. So tread carefully, my friend.

## Setup Petra Wallet

In Web3, a wallet is your digital identity and key to the decentralized world. It lets you own and manage your assets, interact with dApps, and securely handle transactions. With so many options in the market to choose from, Petra Wallet stands out as the top dog. With its user-friendly interface, robust security features, and seamless integration with Aptos, Petra makes accessing and managing your assets a walk in the park. It's the paw-fect companion for your web3 adventures!

First, we will set the wallet use to build our dApp.

1. Download the [Petra Aptos Wallet Chrome extension](https://petra.app/).
2. Click the “Create New Wallet” button.
3. Create a password and securely store your recovery phrase, never share it with anyone. Write it somewhere because if you lose it, you will never have a way to recover your account. So be mindful of that.

( Pin the Petra Aptos Wallet extension to your taskbar, coz we’ll be needing it quite often )

![image.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image.webp?raw=true)

## Change the network

We will be deploying our code to the Testnet, so we need to change the network that our wallet is connected to. Follow the steps given below to change it:

1. Go to “Settings” which is at the bottom right corner.
2. Click on the “Network”.
3. Select “Testnet”.

And with this, we have successfully changed the network.

![image69.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image69.webp?raw=true)

## Copy the essentials

There are two key essential pieces of information that you’ll require quite often for development and deployment.

1. Wallet Address
2. Private Key

Follow the steps given below to copy and save these:

1. Go to “Settings” which is at the bottom right corner.
2. Scroll down and go to “Manage account”.
3. Enter the password for your Petra wallet and click on Next.
4. Copy the wallet address and save it somewhere secure.
5. Click on “Show” under the Private key.
6. Copy the private key and save it somewhere secure.
- Make sure to NEVER SHARE the private key with anyone. This is very private info and if someone gets access to it, they can hack into your account easily. So stay careful and safe!
    
    ![image25.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image25.webp?raw=true)
    

## Fund the wallet

Here we have another important step to do and that is to fund the wallet. We need money to deploy our code so let’s ask for some fake money. Aptos deals in APT coins.

Click on the “Faucet” button and you will get 1 APT. Well, I clicked it twice to get 2 APT 😇.

![image22.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image22.webp?raw=true)

## Installation on System

I’ll tell you step-by-step installation for your operating system (OS) which might be Mac, Linux, or Windows. So, opt for the OS you are using, and follow the steps.

### Installation on Mac

![image14.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image14.webp?raw=true)

1. First, you need a brew package. The brew allows you to install the packages on Apple easily. Open a terminal on your Mac and run the following command. It will ask for your laptop’s password, provide it, and continue with the installation.
    ```
    /bin/bash -c "$(curl -fsSL <https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh>)"
    ```

2. Open a new terminal and run the following commands:
    ```
    brew update
    brew install aptos
    ```

3. Now restart the terminal or open another terminal and run the following command to verify if the CLI is installed.
    ```
    aptos help
    ```

How easy was it~

> **Well, if you are a Mac user, the installation part is done, move to the next lesson.**

### Installation on Linux

![image38.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image38.webp?raw=true)

Before starting, just a little heads up: The set of instructions that we’ll discuss are of Ubuntu-based systems and anyone using a different Linux distribution can use their native package managers to install the same dependencies.

Open the terminal and run the following command to install the package. It will ask for your laptop’s password so provide it.
```
sudo install apt-get
```

Aptos peeps suggest that the best and easiest way to install the Aptos CLI tool is through Python script. So let’s install it by running the following command:
```
sudo apt-get install python
```

It will install the latest version of the python. You need a 3.6+ version. You can verify it using `python --version`.

Next, you have to ensure that you can use Python in every terminal so to do that you add the path where Python is installed to an environment variable called PATH. The variable PATH instructs Linux to the directories where it can search for the packages.

So let’s add Python to your PATH:

- Run `which python`, it tells where python has been installed on the system i.e., it gives you the path, COPY IT!
- Now run the following command after replacing `/path/to/python` with the path you copied to add the python path to your variable:
    ```
    export PATH=$PATH:/path/to/python
    ```

### Install Aptos CLI
You can install Aptos CLI using either `curl` or `wget`. The choice is up to you to go whichever option you want to. I am listing down both for you:

**Using curl**
- Install `curl`:
    ```
    sudo apt-get install curl
    ```
- Install Aptos CLI using the following command:
    ```
    curl -fsSL "https://aptos.dev/scripts/install_cli.py" | python3
    ```

**Using wget**
- OR You can use wget which is a tool to download the files from the internet from the terminal directly. You can install it first:
    ```
    sudo apt-get install wget
    ```
- Install Aptos CLI using the following command:
    ```
    wget -qO- "https://aptos.dev/scripts/install_cli.py" | python3
    ```

### Verify installation
Restart the terminal or open another terminal and run the following command to verify if the CLI is installed.
```
aptos help
```

> **Awesome! You are good to go to the next lesson!**

### Installation on Windows

![image20.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Set%20Up%20the%20Environment%20Wizard/image20.webp?raw=true)

You can install the Aptos CLI using the python. So first install Python by following the steps given:

1. Visit the [Python website and download the package](https://www.python.org/downloads/windows/) according to your system architecture.
2. Check your Downloads folder to see the package.
3. Install the package and you’re set up for python.

Now follow the steps given below to install the CLI:

1. Open PowerShell using the Start Menu.
2. Run the following command:
    ```
    iwr "https://aptos.dev/scripts/install_cli.py" -useb | Select-Object -ExpandProperty Content | python3
    ```
3. The command’s output will show you a command to set the PATH variable, make sure to run it.
4. Run the following command to verify if the CLI is installed.
    ```
    aptos help
    ```

## That’s a wrap

Whew! We’ve conquered the installation phase, and now it’s time to dive into the fun stuff! Get ready because in the next lesson, we’re rolling up our sleeves to create a project for our Calculator dApp. Let’s bring those coding dreams to life!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/2.%20Getting%20Started%20with%20Development%20on%20Aptos/1.%20Set%20Up%20the%20Environment%20Wizard.md

Set Up the Environment Wizard

# The Starting Line: Creating Your Calculator Project

Alright! We've set up our wallet and the Aptos-cli, and now it's time to start cooking up our calculator DApp. In this lesson, we'll guide you step-by-step on setting up your project so you can deploy your smart contract to the Aptos Network. Later, you'll learn how to interact with it using our pre-built frontend 😉. So let's get started!

## Setting the stage

We've got you covered with a GitHub repository, so you won't need to stress about building the front end for the calculator. You can focus on the fun part: writing and deploying the smart contract on the Aptos Network. We've organized multiple branches to keep things streamlined for all upcoming lessons. Let's get the ball rolling!

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

```
gh repo fork https://github.com/0xmetaschool/Building-on-Aptos-boilerplate.git --clone
cd Building-on-Aptos-boilerplate
```

This will clone the boilerplate code of your project onto your system and fork the repository to your Git account as well. And we will change the folder to this cloned repo.

Now run the following command in your terminal:

```
aptos init
```

1. When you run the above command, you’ll be prompted to choose a network. Type `testnet` and press Enter.
2. Next, you’ll be asked to provide the private key. Use the same private key you copied and saved from the previous lesson. Paste it into the terminal.

And voilà! The Aptos CLI is successfully set up.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXc_4oI5H8Px_xKELlj5flfcsoQWQDftZPrSJN_Qb9kfunzd2E92Rus8AkTyg4wi4ceoL80j1JylInOMUmVbsh1ZPYuTB4hejlVS1gWwBlgi99BayWno7HSIgJNf6wtTPjkj-9yKIYT4rhPMxtm1IWwsxaU?key=jbOu4IsavycRvKJlC-DSMQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/The%20Starting%20Line%20Creating%20Your%20Calculator%20Project/Aptos%20C2%20L5%20P1.webp?raw=true)

We have the Move package. Here's how the project directory looks like:
![Frame 3560415](https://github.com/user-attachments/assets/bb661539-1435-468d-968e-28e050598ac7)

Before moving on, let’s understand the structure of the Move package.

## Move package: Unpacking the package

Just like Python uses .py files and Solidity uses .sol files, Move code files have a .move extension. Since Move focuses on building on the blockchain, we need a file to store all the deployment details and configurations. That's where the Move.toml file comes in handy!

The Move package is a folder that contains all the code files and the configuration file just like we have created one for Calculator dApp. Let’s understand the Move package structure with an example of baking a cake that you need to deliver to someone:

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfv2oQzjc-GrdGvEPOoddfWk_gFP3O2SBIh3S7CLE8ZqViBqoiGzw4qnW3pI5uCAZwXBcv1KUdagW714pb9V1Kso5rhUI0A-H3kJPMa63HsyDWWloZOIZwljvejdjOuaAWosm4TgG-zp7OhlX3ciVvn77Q?key=jbOu4IsavycRvKJlC-DSMQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/The%20Starting%20Line%20Creating%20Your%20Calculator%20Project/Aptos%20C2%20L5%20P3.webp?raw=true)

- **Move Package**: Think of the Move package as a recipe book for baking a cake. It contains all the necessary instructions and ingredients to create a delicious cake from scratch.
- **Move Source Code Files (.move)**: These are like the individual steps or instructions within the recipe book. Each Move source code file represents a specific part of the baking process, such as mixing ingredients, baking the batter, and decorating the finished cake.
- **Move Configuration file (.toml):** These are like instructions to deliver the cake safely i.e. packing the cake into a box, providing the address where we want to deliver to, calling the rider, and finally delivering the cake successfully. So, the file contains information to deploy our code files to the specified blockchain.
- **Test Directory:** In addition to these, you can also have a test directory and a file to test out your code. Writing tests is crucial for ensuring the correctness and reliability of your code.

## What is Move.toml?

The `Move.toml` file is where all the important details about your package are stored, such as its name, version, and dependencies. But what does that mean for you? It means this file contains everything you need to deploy your code to the blockchain. Exciting, right?

Here’s a sample of `Move.toml` similar to the one that will be present in your project.

```
[package]
name = 'calculator_l05'
version = '1.0.0'

[dependencies]
AptosFramework = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-framework", rev = "testnet" }

[addresses]
metaschool = "<Enter-your-wallet-address-here>"
std = "0x1"
```

The `Move.toml` has different sections, and each one has a specific job to do. Let’s try to understand this file a bit more!

### **`[package]`**

This section is all about your package itself. It's where you declare the name and version of your project. Think of it as the title page of a book - it tells you what the story is about and who wrote it. Here the package name is `calculator_l05`.

### **`[dependencies]`**

Dependencies are like the supporting cast in your project's story. There are other packages or libraries that your project relies on to function smoothly.

### **`[addresses]`**

The `[addresses]` section allows you to assign aliases to addresses, making them easier to reference in your code. We give addresses to modules here and there can be multiple modules of one package. If you have seen wallet addresses before, you would know how complex they look. Wouldn’t it be nice to reference them with something easier?

### Update Move.toml

Edit the `Move.toml` file by replacing the `<Your-wallet-address-goes-here>` with your wallet address under the `[addresses]` section:

```
metaschool = "<Your-wallet-address-goes-here>"
```

We use metaschool as a nickname for our wallet address to make it easier to reference and maintain. This way, we don’t have to keep typing out the long address, which makes our code cleaner and easier to read. Even though our smart contract is pretty simple right now, using aliases like this will be a big help when we start working on more complex projects in the upcoming courses.

And yayyy, we have learned a lot, haven’t we? From being a novice to knowing so much about the Aptos Move, you have come a long way, Great job!

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfEpZzT9HK4Rg20L8azQiLeYYOr0FgQBuOvbWhvWuViKc4xS3TaW2Ds5OhY19u1BdNpqTSFaB8h8CI_Vs47sAMC_5ggMTKZ9Zs0KQOAi_jgHuWiUjNfdMigb3zqBwDXG1_wCq6T5ZnmeIwDNcRgknMkKRU?key=jbOu4IsavycRvKJlC-DSMQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/The%20Starting%20Line%20Creating%20Your%20Calculator%20Project/Aptos%20C2%20L5%20P4.webp?raw=true)

## That’s a wrap

Wow, we've been on a wild ride, haven't we? You've been absolutely stellar in crafting your project and mastering the Move package structure. Now, in our next lesson, get ready to dive headfirst into coding for our Calculator dApp and launching it into the blockchain! Exciting times ahead!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/2.%20Getting%20Started%20with%20Development%20on%20Aptos/2.%20The%20Starting%20Line%20Creating%20Your%20Calculator%20Project.md

The Starting Line: Creating Your Calculator Project

# Interacting with your Calculator Project

Hey, buddy! Kudos on creating your Calculator project and mastering the basics of the Move package structure. What’s next? Well, the lesson title gives it away but let me reiterate. Yep, we're going to "add" our Calculator dApp to the Aptos blockchain and "subtract" any doubts by interacting with it! Sounds exciting, right? So, let’s not "divide" our attention any longer and dive right in!

## Quick Code Drop

Now navigate to `sources/calculator.move` and we have the following code there:

```
module metaschool::calculator_l05
{
    use std::string::{String,utf8};
    use std::signer;

    struct Message has key
    {
        my_message : String
    }

    public entry fun create_message(account: &signer)
    {
        if (!exists<Message>(signer::address_of(account))){
            let message = Message {
                my_message : utf8(b"I am a Calculator Dapp")            
            };
            move_to(account,message);    
        }
    }

    public fun get_message(account: &signer): String acquires Message {
        let calculator = borrow_global<Message>(signer::address_of(account));
        calculator.my_message
    }
}
```

A bit too much, All of a sudden? No need to fret. By the end of this course, you'll be equipped to handle much more than what meets the eye now. To give you a glimpse into our code's functionality:

- `create_message()`: This function stores a default message ("I am a Calculator Dapp") on the blockchain if it's not already there.
- `get_message()`: It retrieves and returns the stored message from the blockchain.

Despite its name, this particular Calculator dApp won't crunch any numbers just yet. Instead, it politely announces its existence with the message *"I am a Calculator Dapp."* But fear not, we'll gradually build our calculator with all its glorious functionalities throughout the upcoming lessons.

Let’s compile the code using the following command:

```
aptos move compile
```

Now, deploy the code using the following command:

```
aptos move publish --skip-fetch-latest-git-deps
```

Type “yes” when the command asks if you want to pay for the transaction. And kudos, you have deployed the code successfully. This is a snippet of a successful deployment.

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Interacting%20with%20your%20Calculator%20Project/Untitled.webp?raw=true)

## Let’s smash some buttons

Well, yes now it’s time to see what our calculator dApp looks like from frontend. 

1. Open your terminal and change the directory to the `interface` folder using the following command:
    
    ```
    cd ./interface
    ```
    
2. With the terminal still in the `interface` directory, install all the necessary dependencies by running:
    
    ```
    npm install
    ```
    

You can ignore the warning generated in the terminal. Once done you should be able to find a `.env` file in your `interface` folder and it would look something like this:

```
REACT_APP_MODULE_ADDRESS = "<Enter-your-wallet-address-here>"
REACT_APP_MODULE_NAME= "calculator_l05"
```

Replace your Petra wallet address with `<Enter-your-wallet-address-here>`. And now we are all set, so let’s run the dApp using the following command, wohooo:

```
npm start
```

Well, this is how the dApp will look like in your browser, try clicking the turn-on button to fetch the message from our Smart Contract.

![FirstInteraction.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Interacting%20with%20your%20Calculator%20Project/FirstInteraction.webp?raw=true)

## Pushing it to Git

Make sure you are in `Building-on-Aptos-boilerplate` folder. If you are in `interface` folder just run `cd ../` to return to the previous directory. Push your code to your GitHub repository using the following commands. 
```
git add .
git commit -m "code update"
git push
```

## That's a wrap

Woohoo! High-fives all around! We’ve officially launched our code into the digital cosmos! 🚀 Now, we’re like digital astronauts ready for our next cosmic adventure. In our next lesson, prepare to decode the secrets of Move program structures. It’s like unraveling the map to hidden treasure—you’ll navigate our Calculator DApp like a seasoned explorer! 


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/2.%20Getting%20Started%20with%20Development%20on%20Aptos/3.%20Interacting%20with%20your%20Calculator%20Project.md

Interacting with your Calculator Project

# Unleashing the Power of Move Program Structure

Hey there, champs! 🌟 We’re absolutely blown away by how effortlessly you've set up your development playground and even taken the plunge to launch your inaugural smart contract! 

Now, let's tackle the million-dollar question: What exactly is a smart contract? Picture it as a digital rulebook, jam-packed with codes and conditions, designed to operate flawlessly within a specific framework.
![self-executing-contract-ezgif com-resize](https://github.com/0xmetaschool/Learning-Projects/assets/130544719/e111de0d-9287-40e4-b1b9-502211fbd0e8)


But hey, navigating this digital realm can sometimes feel like trekking through a jungle without a map! 😅 That’s why mastering the foundational structure of Move contracts is absolutely crucial before we venture deeper into the unknown.

Our journey begins with a gentle introduction to Move's heart and soul: Modules!  But before we dive headfirst into these modules, let's pinpoint their place in the vast Move universe. Trust us, once we’ve decoded the mysteries of storage, the rest will unfold like pure magic! 

## Global storage

Welcome to Move World, where global storage rules! It's like a giant digital treasure chest, holding all the precious data ready to be discovered!

You see, in the vast expanse of the blockchain, data must stand the test of time—it's all about persistence, baby! We're talking about data that's so resilient, it never says goodbye and remains steadfast across every corner of the digital universe. So, whenever anyone needs a quick data fix, it's right there at their fingertips, ready to be unleashed!

![Global storage.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Unleashing%20the%20Power%20of%20Move%20Program%20Structure/Global_storage.webp?raw=true)

Now, let's get to the exciting part—how does all this tie back to Move programs? 🚀 Let's uncover the magic together!

## Modules in the Move programming language

Think of Modules like magic libraries full of powerful tools that make coding fun!

So, what's inside these Modules? Well, they've got Struct types, which are like special containers that hold important info. And then there are functions, which are like little helpers that do all sorts of awesome stuff!

Modules are like treasure chests stored in a special place where everyone can access them. And the best part? We can use these Modules again and again in different parts of our code! It's like having a superpower that lets us build amazing things without doing the same work over and over again.

### Coding structure

Let’s straight away dive into the coding structure of a module in the Move programming language just like we went through the script coding structure. So in our calculator code, the first line of the smart contract was:

```
module metaschool::calculator {}
```

In Move, we declare a smart contract using the `module` keyword, just like we declare a smart contract in Solidity using the `contract` keyword. 

- The `metaschool` is the name we give our package at the time of package creation. Yes, we created a package named `metaschool` using the command `aptos move init --name metaschool`.
    - Instead of giving a package name, we can give the address of our package too, where the module will be stored in the global storage at the specified address. But that gets confusing, so it’s a common practice to go with the name of the package.
- The `calculator` that comes after `:` is the name of the module that we are creating in our package. There can be multiple modules in one package that’s why it's important to name each module separately. For example, if we add another module named `area_calculator` because it calculates the area of a specific shape, then we should name it differently for ease.

## Components in module

The module mainly contains the following components. The order of the components doesn’t matter. They can be written in any order, but to keep things organized, follow this order. 

1. `<import modules>`: A module can also import any other module. We can do it, but it wasn’t needed for our first code so we did not utilize it.
2. `<struct>`: In modules, you can create the structs to store data securely and efficiently. We will explore this more in the upcoming lessons.
3. `<functions>`: You can define multiple functions within a module and call them from any other module or script that imports the module. 

![Untitled (7).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Unleashing%20the%20Power%20of%20Move%20Program%20Structure/Untitled_(7).webp?raw=true)

In the following code, we imported two modules using the `use` keyword, created one struct, and created two functions that are used to print and set up the message.

```
module metaschool::calculator
{
		// <import modules>
    use std::string::{String,utf8};
    use std::signer;

		// <struct>
    struct Message has key
    {
        my_message : String
    }

		// <functions>
    public entry fun create_message(account: &signer)
    {
        if (!exists<Message>(signer::address_of(account))){
            let message = Message {
                my_message : utf8(b"I am a Calculator Dapp")            
            };
            move_to(account,message);    
        }
    }

    public fun get_message(account: &signer): String acquires Message {
        let calculator = borrow_global<Message>(signer::address_of(account));
        calculator.my_message
    }
}
```

- **Note:** The name of the module in Aptos should start with a small alphabet (`a`-`z`) and can contain an underscore (`_`), small alphabets (`a`-`z`), or digits(`0`-`9`) after the first letter. In short, the module name should be in `snake_case`. For example, `my_module123`, `account`, `my_module`, `module123`, etc, all are valid names.

Now that we know the basic way of creating a smart contract in Aptos Move. Let’s understand another important concept which is how to import one module into another. 

## Use keyword

The use keyword is used to import code from other modules or libraries into the current scope. In simpler terms, think of it like borrowing a book from a library. To borrow the book, You’ll need the “address” of the library and know which  “book” you want to borrow.

The syntax for using the `use` keyword is pretty simple.

```
use <Address/Alias>::<ModuleName>;
```

The `use` keyword is followed up by the `Address` of the module and the `Module` name of whichever component you want to import.

We used the following in our code:

```
use std::string::{String,utf8};
use std::signer;
```

- `std` represents the Move standard library, it’s a collection of really useful components that you can freely import and use within your code. We will see a bunch of these components later up in our lessons like `debug` module. We can print our message using the `print()` from the `debug` module in the code.
- Move does not support the native type for strings. But we can use it by including the `string` module.
- We will explore `signer` later in the upcoming lessons.

## That’s a wrap

Learning how to create contracts and use modules within each other is super important! Why, you ask? Because it helps make your code easy to understand and manage big projects without any fuss! Let's jump into this adventure together and explore the wonders of Move! 🌟


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/2.%20Getting%20Started%20with%20Development%20on%20Aptos/4.%20Unleashing%20the%20Power%20of%20Move%20Program%20Structure.md

Unleashing the Power of Move Program Structure

# Mastering the Art of Structuring Your dApp

Hey there, rockstars! Welcome back! We're absolutely thrilled to see you taking on your first Move project and totally rocking that calculator dApp.

Today, we're diving into the fun part – giving our calculator dApp some structure. This step is super important for any Move dApp, and especially for our calculator dApp built with the Move programming language.

When we talk about structuring, we're talking about adding structs to the module of our dApp. But don't sweat it – we'll break down what structs are all about before we weave them into our `calculator` module. Let's get this party started! 

## What is exactly the struct?

Imagine you have three awesome toys: a speedy car, an Iron Man action figure, and a cuddly teddy bear. Your shelf is pretty cramped, so you decide to put all these toys into one box labeled "toys."

![box.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Mastering%20the%20Art%20of%20Structuring%20Your%20dApp/box-gif-ezgif.com-optimize%20(1).webp?raw=true)

That's basically how a struct works! You group different types of data that represent certain things together. In our toy analogy, the box acts like a struct, keeping all your toys organized in one place. Now, let's take a peek at a coding version of this example:

```
Box {
    toy1,
    toy2,
    toy3
}

```

In the coding world, a struct lets you store various types of data together in one neat package. You could store a number, a string of letters, a boolean flag, and more, all within a single struct. 

### Struct declaration

In Move, we declare a struct using `struct` keyword.

Imagine you need to send a parcel to your friend. You want to keep track of your address, your friend's address, the parcel’s name, the shipment price, and whether the parcel has been delivered. Here's how you can bundle all this information into a struct:

```
struct Parcel {
    address sender;
    address receiver;
    u64 shipmentPrice;
    bool delivered;
}

```

Pretty neat, right? We’ve combined different data types into a single struct called `Parcel`. This way, all your parcel information is organized in one place. Don’t worry about the data types for now because we will discuss them in detail in the upcoming lessons.

### Creating and initializing the struct variable

Now that we've defined our struct, the next step is to learn how to use it and fill in all the juicy details. To do this, we create a variable of our struct type. Yep, you heard it right—type struct! When we create a struct, it's like crafting a brand-new data type that bundles together multiple pieces of data.

Let's see how to create a variable for our `Parcel` struct:

```
let parcel = Parcel {
    sender: 0x2,
    receiver: 0x3,
    shipmentPrice: 20,
    delivered: false
};

```

What just happened here? We created a variable named `parcel` of type `Parcel`, and then we initialized each field within our struct with specific values. Don’t worry about the fields and their types for now because we will discuss them in the upcoming lessons.

This way, all your parcel info is neatly packed into one variable, making your code cleaner and more efficient.

## Why structs are awesome

Here’s a quick rundown of why structs are a game-changer:

- **Complex Data Handling**: Structs let you handle complex data structures that combine various data types.
- **Organized and Secure**: They group related data fields together, promoting privacy, organization, and encapsulation.
    
    ![security-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Mastering%20the%20Art%20of%20Structuring%20Your%20dApp/security-ezgif.com-optimize.webp?raw=true)
    
- **Modular Magic**: Structs encapsulate data and behavior, making your code modular and reusable across different parts of your program.
- **Clear and Maintainable**: By bundling related data, structs make your code easier to read and maintain.

## Cool struct features in Move

Before we dive deeper, let’s check out some unique features of structs in Move that make them special:

- **No Visibility Specifiers**: Structs can only be created or destroyed within the module they’re defined in and can’t be accessed by other modules.
- **Module-Scoped**: Structs are only accessible within the module that defines them.
- **No Copying or Dropping**: In Move, structs are linear and ephemeral, meaning they can't be copied or dropped. This mirrors real-world assets like money, which shouldn't be duplicated or lost.
    
    ![no-money-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Mastering%20the%20Art%20of%20Structuring%20Your%20dApp/no-money-ezgif.com-optimize.webp?raw=true)
    

This feature of not being copied or dropped helps model real-world assets, ensuring they remain unique and don't disappear unexpectedly.

Now, you're all set to use this struct in your Move project and make your dApp even more awesome! 🚀 Let's keep the momentum going and have some fun coding! 

## Let’s define struct in our calculator dApp

First, remove the current code in `calculator.move` file, and let's write it from the beginning. Add the below code in the file:

```
module metaschool::calculator {
    struct Calculator {
        result: u64,
    }

    fun create_calculator(){   
        let calculator = Calculator { result: 0 };
    }
}
```

Let’s focus on the struct part and understand what we did in the code.

- We created a `Calculator` struct inside the `calculator` module with one field, `result`. Here, we will use a `calculator` struct to store the result of the calculator's operation. For example, if we want to store the addition result, we will store it in the `Calculator`'s `result` field.
**Note:** It is important to specify the data type for the struct field. Don’t worry! We will explore data types in detail in upcoming lessons.
- Next, inside the function (`create_calculator`), we are initializing the `calculator` variable using the `Calculator` struct.

Now, we also have to update the name in `Move.toml` file. Under `[package]` update the name to 'calculator', same as the module name in the code.

## That’s a wrap

In Move, structs play an important role because they allow us to store crucial data with ease so that the data can be easily manageable and accessible. Whew! Next, we will learn how ownership and resources work in the Aptos Move world!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/3.%20Structs%20and%20Resources%20in%20Move/1.%20Mastering%20the%20Art%20of%20Structuring%20Your%20dApp.md

Mastering the Art of Structuring Your dApp

# Unlocking DApp Power: Ownership & Resources

Welcome back, rockstars!! 🌟 You totally nailed the last lesson by mastering structs and seeing how crucial they are in the world of Aptos Move. You even implemented structs in your `calculator` dApp. Awesome job!

But we hit a snag with our struct. Remember how we mentioned that in Move, you can't copy, drop, or use structs outside their defining module? Well, it is what it is. But don’t worry! There’s a way around it. We can add abilities to structs so that we can copy, drop, or save them in the global state, allowing us to fetch and use them whenever we want.

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Unlocking%20DApp%20Power%20Ownership%20&%20Resources/Untitled.webp?raw=true)

But in Move, a resource-oriented programming language, we call these structs a resource that cannot be copied or dropped.

In this lesson, we are going to get an overview of resources, type abilities, ownership, signer, acquires, and how Move is a resource-oriented programming language, and then supercharge our `calculator` dApp with all this knowledge. Let’s get started and have some fun! 

## Let’s discover resource-oriented programming

First, let's get a grip on what kind of language Move is. You've probably heard that Java, Python, and C++ are object-oriented programming languages. Well, Move has its special type too!

Move is a resource-oriented programming language. It’s a fresh way to manage memory where a resource is owned by its owner. In Move, what we call structs and objects are known as resources. A resource is essentially a bundle of variables that can only be copied once at a time. This means if you pass a resource to a function, you can’t use it elsewhere at the same time.

Here are the three golden rules for resources in resource-oriented programming:

1. **Unique Memory Location**: Each resource exists in only one memory location - no duplicates allowed!
2. **Ownership Defined by Storage**: There’s no central ledger tracking ownership; it’s all about where the resource is stored.
3. **Exclusive Access**: Only the owner of the resource can access its methods.

These principles show that resources provide a new way to represent asset ownership and the characteristics of crypto-enabled digital assets directly within the programming language. A standout feature of Move is the ability to define custom resource types. These types are used to create secure digital assets with rich programmability.

## WTH are resources

Alright, let's dive back into the fascinating world of *Resources*! We've touched on this before, but let's give it a proper review.

In Move, if struct values can't be copied or dropped, they're called resources. Essentially, in Move programming, we refer to structs and objects as resources, and these bad boys can’t be copied or dropped.

![Untitled (6).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Unlocking%20DApp%20Power%20Ownership%20&%20Resources/Untitled_(6).webp?raw=true)

By default, structs are linear and ephemeral. Sound complicated? Let’s simplify it! It means structs can't be copied, dropped, or stored in global storage. But don't worry, Move gives us superpowers to change this with abilities like key, store, copy, and drop.

So, remember, we've got four cool abilities we can attach to our resources: key, store, copy, and drop. Easy peasy!

Next, let’s get a brief introduction to type abilities which give resources the ability to be copied, dropped, or stored in a global storage. Let's keep the fun rolling! 🚀

## WTH are type abilities

By default, resources have no ability, meaning we can’t copy a struct, we can’t store it in a global storage, and we cannot even destroy it. So, to cater to this, type abilities were introduced. This means they give structs and data types different kinds of abilities like the ability to copy the struct or store them in the global state.

So, Move programming language offers four types of abilities that a struct can have. These abilities are key, store, copy, and drop.

As per [Aptos Move abilities definitions](https://aptos.dev/move/book/abilities/), the definition of four abilities are:

- [`copy`](https://aptos.dev/move/book/abilities/#copy)
    - Allows values of types with this ability to be copied.
- [`drop`](https://aptos.dev/move/book/abilities/#drop)
    - Allows values of types with this ability to be popped/dropped.
- [`store`](https://aptos.dev/move/book/abilities/#store)
    - Allows values of types with this ability to exist inside a resource in global storage.
- [`key`](https://aptos.dev/move/book/abilities/#key)
    - Allows the type to serve as a key for global storage operations.

To use these abilities with a resource, we use `has` keyword like this:

```
struct has key {
		// struct field go here
}
```

## How ownership works in Move

In Move, ownership works like a super-organized system for managing valuable assets and memory. Each asset, or resource, has just one owner at a time, and ownership can be transferred from one person to another. This clever system helps Move keep things tidy, avoid data clashes, and manage memory like a pro.

Imagine you have a token representing a digital asset. When you transfer that token to someone else, you're passing the ownership of that asset to them. This ensures there's always a clear owner for each asset, maintaining order and preventing conflicts in your program.

By handling ownership this way, Move ensures efficient memory use, keeps data secure, and ensures smooth operations within the program. It's like having a super-organized digital ledger that tracks who owns what.

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Unlocking%20DApp%20Power%20Ownership%20&%20Resources/Untitled%201.webp?raw=true)

To manage ownership, Move provides some handy functions that we'll explore in a bit: `move_to`, `borrow_global`, `move_from`, and `borrow_global_mut`. The `move_to` function is super simple—it moves the resource to the given account under the `signer.address`, pushing the resource to the blockchain. Get ready to dive into these functions and see how they keep everything running smoothly!

## WTH is signer

In Move, the `signer` is a built-in resource type that plays a crucial role in authentication and authorization. It's like having a digital signature that grants you the power to act on behalf of a specific address on the blockchain.

The `signer` is a capability that allows the holder to perform actions on behalf of a particular `address`.

The `signer` values are unique because they cannot be created directly within the Move code. Instead, they are created and provided by the Move Virtual Machine (VM) itself.

Here's an example of how a `signer` is used in a script:

```
module example::signer_example {
    use std::signer;
    fun main(s: signer) {
        assert!(signer::address_of(&s) == @0x42, 0);
    }
}
```

In this script, the VM will automatically create a `signer` value and pass it into the `main` function. The `assert` statement checks that the `address` wrapped by the `signer` is `0x42`. If the module is sent from any other address, it will abort with code `0`.

### `signer` Operators

The `std::signer` standard library module provides two utility functions for working with `signer` values:

- `signer::address_of(&signer): address`: Returns the `address` wrapped by the `&signer`. Which means it will return the address of the signer.
- `signer::borrow_address(&signer): &address`: Returns a reference to the `address` wrapped by the `&signer`.

Get ready to master these functions and see how they can make your Move project even cooler. Let’s keep the excitement rolling and dive into the details! 🚀🎉

## Using signer in calculator dApp

Let’s see how you can use the signer in your calculator dApp.

```
module metaschool::calculator {
		use std::signer;	

		// Resource with key ability
    struct Calculator has key {
        result: u64,
    }

		// Passing the signer address to the function
    fun create_calculator(account: &signer) {
	    // Defined the Calculator instance
	    let calculator = Calculator { result: 0 };
	    // Published the Calculator instance to the account provided
	    move_to(account, calculator);
    }
}
```

This code won't run perfectly just yet, but let's break down what we did here:

1. We gave our `struct` resource the `key` ability, allowing us to store the `Calculator` resource in the global storage.
2. We passed the `signer` account to the `create_calculator` function. The `&` sign with `signer` allows us to use the `signer::address_of(&signer): address` function, which we'll dive into in upcoming lessons.
3. We used `move_to` to publish the `Calculator` resource to the signer's account.

So, even though it won't run just yet, we've set up some crucial steps for our `calculator` module. Keep going—you're doing great!

## That’s a wrap

Phew, you did great!! Grasping how Move is resource-oriented and understanding resources, ownership, and signer functionality is key to programming securely and efficiently in Aptos Move.

But wait, there’s more!! We still need to dive into type abilities and explore different functions to manipulate resources. So, in the next lesson, we’ll dig into these concepts in detail and incorporate them into our calculator dApp. Stay tuned!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/3.%20Structs%20and%20Resources%20in%20Move/2.%20Unlocking%20DApp%20Power%20Ownership%20%26%20Resources.md

Unlocking DApp Power: Ownership & Resources

# Jazzing With Type Abilities and Resources

Welcome back, folks!! We're thrilled to have you with us again! Last time, you mastered the concepts of ownership, signers, and resources in Aptos Move.

In this lesson, we're going to take things up a notch. First, we'll dive deep into type abilities, then we'll explore various functions for manipulating resources, and finally, we'll tackle a brand-new concept called acquire.

By the end of this lesson, we'll have all these exciting concepts integrated into our `calculator` dApp, and you'll see our `create_calculator` function in action. Let's get started! 

## Usage of resources

We did a small overview of type abilities, now it is time to dive deep into them and learn them in detail using examples. Eventually, we will need these type abilities in our `calculator` dApp.

![Untitled (4).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Jazzing%20With%20Type%20Abilities%20and%20Resources/mariostruct_2-ezgif.com-resize.webp?raw=true)

### Using `key`

In Move, the `key` ability is like giving your structs or resource types a unique identifier. Think of it as a special address where the struct or resource is stored and accessed in the global storage. By default, every member of a struct with the `key` ability also has the `store` ability, meaning it can be safely stored in the global storage.

Imagine you own a pizza shop and want to keep track of the different types of pizzas you offer. You can create a `Pizza` struct with the `key` ability like this:

```
struct Pizza has key {
    price: u64,
}

fun create_pizza(account: &signer) {
    let pizza = Pizza { price: 0 };
    move_to(account, pizza); // Move the `Pizza` struct to the account's global storage
}

```

In this example, the `Pizza` struct has a single field `price` of type `u64` (an unsigned 64-bit integer). The `create_pizza` function takes an `account` (a reference to a signer, like a customer's ID), creates a new `Pizza` struct with a default price of 0, and then uses the `move_to` function to store this `Pizza` struct in the global storage associated with that `account`. It’s like adding a unique pizza to a customer's order history!

### Using `store`

The `store` ability allows a struct to be stored inside another struct as a field, and then as a key in the global storage. For example, our `Pizza` struct could look like this: `struct Pizza { price: u64, toppings: Toppings }`. This means the struct with the `store` ability doesn't always have to be a top-level resource in the global storage.

You might be wondering, after learning about the `key` ability, if the fields of a struct with the `key` ability always get stored in the global storage. Well, the fields of a struct with the `key` ability indeed have the `store` ability, but they aren't stored as top-level resources.

Let’s take a look at a pizza example using the `store` ability:

```
module pizza::pizza {
    use std::signer;

    struct Toppings has key, store {
        want: bool,
    }

    struct Pizza has key {
        price: u64,
        toppings: Toppings,
    }

    fun create_pizza(account: &signer) {
        let topping = Toppings { want: true };
        let new_pizza = Pizza { price: 0, toppings: topping };
        move_to(account, new_pizza); // Move the `Pizza` struct to the account's global storage
    }
}

```

In this example, the `Toppings` struct has a `bool` field `want`, indicating whether the customer wants toppings. The `Pizza` struct now includes a `Toppings` field alongside the `price`. The `create_pizza` function creates a `Toppings` struct with `want` set to `true`, then a `Pizza` struct with a price of 0 and the toppings. Finally, it moves the `Pizza` struct into the global storage associated with the `account`.

### Using `copy`

Sometimes, you might want to make copies of a struct for various purposes. In Move, the `copy` ability lets you create duplicates. Imagine you want to copy a pizza order for your records:

```
struct Toppings has store {
    want: bool,
}

struct Pizza has key, copy {
    price: u64,
    toppings: Toppings,
}

fun create_pizza(account: &signer) {
    let topping = Toppings { want: true };
    let pizza = Pizza { price: 0, toppings: topping };
    let copy_of_pizza = copy pizza; // `copy` keyword allows you to duplicate the struct
    move_to(account, pizza); // Move the `Pizza` struct to the account's global storage
}

```

In this example, the `Pizza` struct has both `key` and `copy` abilities. The `create_pizza` function creates a `Toppings` struct, a `Pizza` struct, and then makes a copy of the `Pizza` struct using the `copy` keyword. Finally, it moves the original `Pizza` struct into the global storage associated with the `account`. It’s like making a duplicate order slip for your records!

### Using `drop`

The `drop` ability in Move lets you automatically discard a struct when it goes out of scope, helping to manage memory and prevent resource leaks. Imagine you want to create a `Sauce` struct that represents a temporary sauce order:

```
struct Toppings has store {
    want: bool,
}

struct Pizza has key, copy {
    price: u64,
    toppings: Toppings,
}

struct Sauce has drop {
    want: bool,
}

fun create_pizza(account: &signer) {
    let topping = Toppings { want: true };
    let pizza = Pizza { price: 0, toppings: topping };
    let sauce = Sauce { want: true }; // The `Sauce` struct will be dropped after this function scope
    let copy_of_pizza = copy pizza;
    move_to(account, pizza); // Move the `Pizza` struct to the account's global storage
}

```

In this example, the `Sauce` struct has a `bool` field `want` and the `drop` ability. The `create_pizza` function creates a `Toppings` struct, a `Pizza` struct, and a `Sauce` struct with `want` set to `true`. Once the function scope ends, the `Sauce` struct is automatically dropped from memory. It’s like a temporary sauce order you don’t need to keep track of once the pizza is made and delivered!

Get ready to use these abilities and make your Move project even more awesome. Let’s keep the excitement rolling and understand how to manipulate these resources, transfer their ownership, and store them in global storage! 

## Resource manipulation

Alright, adventurers of the blockchain! 🌟 Ready to learn how to wield the power of Move like a true coding wizard? Let’s dive into resource manipulation and see how we can make our data evolve, adapt, and respond to real-time demands, creating dynamic and lively blockchain applications!

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Jazzing%20With%20Type%20Abilities%20and%20Resources/Untitled%20(8).webp?raw=true)

To master resource manipulation in Move, you only need to know five instructions. Each one serves a unique purpose, making your smart contracts super functional. Let’s get started!

### 1. `move_to<T>(&signer, T)`

First up is `move_to()`. This powerful instruction transfers resources or data structures of type `T`.

Imagine you want to transfer tokens from one account to another. You'd use `move_to<Token>(&signer, recipient)` where `&signer` is the sender's account. But be careful! If the sender doesn't have enough tokens, the transaction could abort due to an insufficient balance.

```
module example::example {
    fun transfer_token(sender: &signer, recipient: address, amount: u64) {
        let token: &mut Token = borrow_global_mut<Token>(sender);
        token.balance -= amount;
        move_to<Token>(sender, recipient);
    }
}

```

In this module, the `transfer_token` function moves tokens between accounts. It starts by defining parameters: `sender` (the sender's account), `recipient` (the receiver's account), and `amount` (tokens to transfer). Then, it borrows the sender's tokens (we’ll explain `borrow_global_mut` in a second), subtracts the transfer amount, and finally, uses `move_to<Token>` to transfer ownership to the recipient. This module shows off Move's efficiency in handling token transfers on the blockchain.

### 2. `move_from<T>(address): T`

Need to fetch a resource from a specific address on the blockchain? That’s where `move_from<T>(address)` comes in handy.

You provide the address from which you want to retrieve the resource or data structure. `move_from` will fetch the resource of type `T` and return it to you.

```
module example::example {
    fun get_resource_from_address(address: address): Token {
        move_from<Token>(address)
    }
}

```

In this module, the `get_resource_from_address` function fetches the `Token` resource from the given address using `move_from<Token>(address)`. It's like grabbing a specific item from a vast warehouse shelf and returning it ready for use. Keep in mind, if the address doesn’t hold a resource of type `<T>`, it will abort.

### 3. `borrow_global_mut<T>(address): &mut T`

Want to update a resource? Use `borrow_global_mut<T>(address)` to borrow a mutable reference to a global resource. For instance, say you want to update the balance of a token holder. You'd use `borrow_global_mut<Token>(account)` to access and modify the token's balance. But be cautious! If the requested resource doesn't exist at the specified address, the borrow operation could abort.

```
module example::example {
    fun update_balance(account: address, new_balance: u64) {
        let token: &mut Token = borrow_global_mut<Token>(account);
        token.balance = new_balance;
    }
}

```

Here, the `update_balance` function updates a user’s token balance on the blockchain. It borrows the `Token` resource from the user’s account using `borrow_global_mut<Token>(account)`. This lets us modify the token’s balance without transferring ownership.

### 4. `borrow_global<T>(address): &T`

Next up is `borrow_global<T>(address): &T`, which is similar to `borrow_global_mut`, but it borrows an immutable reference instead. This is handy for read-only operations like checking an account's token balance. If the resource doesn't exist at the specified address, this borrow operation may also abort.

```
module example::example {
    fun get_balance(account: address): u64 {
        let token: &Token = borrow_global<Token>(account);
        token.balance
    }
}

```

In this script, the `get_balance` function fetches and returns the balance of a user’s token. It borrows the `Token` resource from the user’s account using `borrow_global<Token>(account)`. This allows us to read the balance without modifying it.

**Important Note:**

When using `borrow_global` or `borrow_global_mut`, references to global resources act similarly to local storage references. However, you cannot return a reference that points directly to global storage. This restriction ensures safe resource handling in Move programs.

### 5. `exists<T>(address): bool`

Finally, We have `exists<T>(address): bool`. This instruction checks if a resource of type `T` exists at a given address. For example, if you're verifying the existence of a token, you'd use `exists<Token>(account)`. However, it's crucial to note that the abort case for this instruction is unlikely unless there are underlying issues with resource existence checks in the Move VM.

```
module example::example {
    fun token_exists(account: address): bool {
        exists<Token>(account)
    }
}

```

In this module, the `token_exists` function checks if a token exists for a specific account address. The `exists<Token>(account)` instruction returns `true` if the token exists and `false` otherwise. This helps ensure your application can validate the presence of tokens before performing any operations.

## Acquires

Alright, let's dive into the awesome world of resources and how manipulation functions make everything run smoothly!

When a function tries to access a resource using `move_from`, `borrow_global`, or `borrow_global_mut`, it must indicate that it `acquires` that resource. This helps the Move type system ensure that references into global storage are safe and that there are no dangling references.

Let's break down a coding example to make this crystal clear:

```
module example::example {
    struct Token has key {
        balance: u64,
    }

    fun update_balance(account: address, new_balance: u64) acquires Token {
        let token: &mut Token = borrow_global_mut<Token>(account);
        token.balance = new_balance;
        move_to<Token>(account, token);
    }
}

```

In this example, we added `acquires Token` at the end of the function definition. This ensures that the function, which uses `borrow_global_mut` and `move_to`, properly handles the `Token` resource.

And here's a cool tip: when you use a function that has acquired the resource in another module, you don't need to use `acquires` again. Resources defined in one module aren't accessible to another module, ensuring everything stays safe and sound.

Understanding these instructions is key to mastering resource manipulation in Move programming. With these tools, you can build secure and reliable smart contracts that make your blockchain applications dynamic and efficient. Now go forth and code like a wizard! 🚀✨

## Let’s add everything to the `calculator` dApp

Now, let’s move forward and add abilities to the `Calculator` struct that we defined in the last lesson.

```
module metaschool::calculator {
		use std::signer;	

		// Rsource with key ability
    struct Calculator has key {
        result: u64,
    }

		// Function acquires the Calculator resource
    fun create_calculator(account: &signer) acquires Calculator {
    
			  // We check if the signer address already has a Calculator resource
			  // associated to it
        if (exists<Calculator>(signer::address_of(account))){
        
		        // Here, we are using borrow_global_mut to fetch the Calculator resource
		        // associated with the signer address
            let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
            calculator.result = 0;
        }
        else {
        
	        // If no Calculator resource is present for the input signer address
	        // then we create a new instance of a resource
	        let calculator = Calculator { result: 0 };
	        move_to(account, calculator);
        }
    }
}
```

Let's break down what we did in the code!

1. We gave the `Calculator` resource the `key` ability, which lets us publish it to global storage. We talked about this in our last lesson.
2. We added the `acquires` keyword to the function definition. This allows the function to manipulate the `Calculator` resource within the `create_calculator` function.
3. We used the `exists` function to check if the resource for the given signer's address is already published.
4. If the resource exists, we fetch a mutable reference to it using the `borrow_global_mut` function. This lets us access and modify the resource associated with the signer's address.
5. If the resource doesn't exist, we create a new instance of the `Calculator` and publish it to the signer's address using the `move_to` function.

Pretty neat, right? Now, let's see all these concepts come together in action! Try running the program using `aptos move compile` command and then deploy it using the  `aptos move publish` command.

## That’s a wrap

Phew! We’ve packed a ton of cool features into our `calculator` module in this lesson. Now, every user gets their own resource and result for each operation. This means one user can’t mess with another user’s results. Plus, our calculator dApp can handle multiple users and addresses all at the same time.

Don’t forget all the awesome stuff we’ve covered in this and the last lesson, because we’ll be building on it in the upcoming lessons.

Stay tuned, because next up, we’re diving into the world of variables and constants in Aptos Move. It’s going to be a blast! 🚀


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/3.%20Structs%20and%20Resources%20in%20Move/3.%20Jazzing%20With%20Type%20Abilities%20and%20Resources.md

Jazzing With Type Abilities and Resources

# Variable Vibes and Constant Fun in Your Calculator

Welcome back, rockstars! 🤘 We’re thrilled to see you again, ready to dive into more knowledge. Last time, you mastered resources, learned how to add abilities to them, and discovered the art of resource manipulation with various functions.

Now, it’s time to level up! We’re going to explore how to create variables and constants in Move. While our calculator dApp might not need tons of variables or constants, understanding them is crucial. They help us save important data and grasp how to work with functions and structs.

Before we dive in, let’s figure out how to add data to a module. In coding, we call this data “variables.” They help us store anything—numbers, strings, or even conditions like true or false. For example, in our Calculator struct, we have a result field that stores the calculation result.

So, let’s break it down and understand the different types of variables first!

## Different types of variables: Mutable vs immutable variables

There are two types of variables: mutable and immutable variables. Let’s try to understand them.

### Mutable Variables

Mutable variables can change. You can store data in them and modify it later. For example, if you set a variable `var` to `10`, you can change it to `5` whenever you want. Easy, right?

### Immutable Variables

Immutable variables, on the other hand, cannot be changed once data is stored in them. Imagine you have a cookie recipe that always uses brown sugar. You write it down as `sugar = "brown sugar"`. If someone changes it to `"salt"` without you knowing, your cookies will come out salty! That’s why immutable variables are essential—they keep your data safe and unchanged.

![cookies (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Variable%20Vibes%20and%20Constant%20Fun%20in%20Your%20Calculat/cookies_(1).webp?raw=true)

Now that we’ve got the basics down, let’s jump into how Move handles variables.

## Variables in Move

In Move, we use two main keywords to store data: `let` and `const`. `let` is for mutable variables, and `const` is for immutable variables, aka constants. Let’s see how they work!

## `let` keyword

In Move, we use the `let` keyword to declare and initialize the variables. After declaring the variable, you can easily access and modify it later. There are several ways to declare and initialize the variable using the `let` keyword. Let’s discuss them in detail.

```
let <Variable_Name> : <Type>
```

Here, we are simply using the `let` keyword to name the variable and define the type of the variable. Here’s the coding example where we are just declaring the variable. This means we are not storing any data in the variable, for now, we are just defining and declaring the variable. Keep in mind you can do this in Move without initializing the variables.

```
let a : u8;
let b : u8;
```

In this example, we simply declared `a` and `b` variables using the `let` keyword. Remember `u8` is used to identify that `a` and `b` are integers. Don’t worry about this for now. We will cover data types in detail in the upcoming lessons.

Now, let’s initialize the variable meaning let’s just not declare the variable but also store the data in the variables. Even if we store data after declaring the variable it means we are initializing the variables. Here’s the simple structure to do so.

```
let <Variable> = <Expression>
let <Variable> : <Type> = <Expression>
```

Let’s look at some examples now. Remember, it is mandatory to include semicolons at the end of each line in Move.

```
let a : u8;
a = 1;
let b : u8; 
b = 2;
let sum : u8 = a + b; 
sum = sum + b;
```

Here, we first declared `a` and `b` variables and then initialized them using the values. Afterward, we declared and initialized the `sum` variable in a single line. In the end, we tried to change the value of the sum variable.

Also, you can define a struct variable using the `let` keyword. Just like we defined `calculator` variable in our `calculator` dApp.

```
// Rsource with key ability
struct Calculator has key {
    result: u64,
}

// Defining resource variable using the let keyword
let calculator = Calculator { result: 0 };
```

Here, we defined the variable of the resource type `Calculator` using the `let` keyword.

**Note:** Variables should always start with a small alphabet (`a`-`z`) or an underscore(`_`). After the first letter, variables can have underscores, small alphabets (`a`-`z`), upper case alphabets (`A`-`Z`), or digits(`0`-`9`). For example, `simple_u8`, `simpleU8`, etc are valid variable names.

Simple, isn’t it? Let’s move on to another way of declaring the variable. It is important to learn this because even if we don’t use it in our `calculator` dApp it will help us build many other dApps on Aptos Move.

## `const` keyword

In Move, the `const` keyword declares and initializes constants.

![Frame 3560404.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Variable%20Vibes%20and%20Constant%20Fun%20in%20Your%20Calculat/Frame_3560404.webp?raw=true)

Constants are defined at the module level, meaning they’re initialized outside of functions and can be used anywhere in the module. Here’s the syntax:

```
const <Variable> : <Type> = <Expression>
```

A few key points about constants:

- They cannot be changed once defined.
- They must be initialized at the time of declaration.
- They’re mostly used to define module-level constant values.
- They’re private to the module and cannot be accessed by other modules.

Here’s an example:

```
module example::constants {
    const MAX : u64 = 100;

    fun sample_function(){
        let num = MAX;
    }
}
```

Here, we declared and initialized the `MAX` constant globally, allowing it to be used anywhere inside the module.

**> Note:** Constant names should be uppercase or use upper snake case, like `MAX` or `MAX_SUM`.

## Let’s understand the variables used in calculator dApp
So, let’s understand how we defined the struct variables in our last lesson.

```
module metaschool::calculator {
		use std::signer;
		// Rsource with key ability
    struct Calculator has key {
        result: u64,
    }

    fun create_calculator(account: &signer) acquires Calculator {
        if (exists<Calculator>(signer::address_of(account))){
        
		        // Defining calculator variable using let keyword
            let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
            
            calculator.result = 0;
        }
        else {
        
	        // Defining calculator variable using let keyword
	        let calculator = Calculator { result: 0 };
	        
	        move_to(account, calculator);
        }
    }
}
```

In this code:

1. We define the `calculator` variable inside the `if` condition.
2. We also define the `calculator` variable inside the `else` condition.

## That’s a wrap

And that’s it! You’re now equipped with the knowledge of how to declare and use variables and constants in Move. Keep rocking the blockchain world! 🚀 Next, we’ll learn all about the data types available in Aptos Move. 


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/4.%20Variables%2C%20Constants%2C%20and%20Functions%20in%20Move/1.%20Variable%20Vibes%20and%20Constant%20Fun%20in%20Your%20Calculat.md

Variable Vibes and Constant Fun in Your Calculator

# Enrich Your dApp Using Data Types

Hey there, welcome back! In the last lesson, you learned all about declaring and initializing the variables and constants. Now, we need to learn the data types available in Aptos Move. So that we know the different types of data types we can use in our `calculator` dApp.

In the World of programming, Data reigns supreme. It's the fuel that powers our creations, allowing us to mold, shape, and bring ideas to life. Now, imagine a language where the possibilities for data manipulation are boundless. That's exactly what MOVE offers.

 Whether you're storing a simple word, a complex paragraph, a colossal number, or even a crucial address, MOVE's arsenal of data types equips you with the tools to harness data in its various forms.

To get started,  it's essential to understand their fundamental classification. Data types can be neatly categorized into two distinct groups: primitive and non-primitive data types.


- The term **primitive** refers to the basic building blocks of data types that the programming language directly supports. Think of them as the foundation of a house. Examples of primitive data types include unsigned integers (like whole numbers), booleans (true or false values), and addresses (unique identifiers).

- On the other hand, **non-primitive** data types are like the rooms and furniture you build on top of that foundation. They are created by the programmer using primitive data types. Examples of non-primitive data types include vectors (which are like lists) and strings (which are sequences of characters).

Here's a simple example to make it clearer:

- **Primitive data type:** Imagine an unsigned integer as a single Lego brick. It's basic and can be used on its own.
- **Non-primitive data type:** Now, imagine a vector as a structure made from several Lego bricks. It's more complex and built using the basic bricks.

So, primitive data types are the essential elements, while non-primitive data types are more complex structures built from these essentials.

We’ll start with the Primitive data types and work our way around to Non-primitive data types. 

## Unsigned Integers

Let’s kick off primitive datatypes starting with storing numbers. In Move, we have the unsigned integers specifically designed for storing numerical values. This type is perfect for storing whole numbers without decimal places.

![numbers-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Enrich%20Your%20dApp%20Using%20Data%20Types/numbers-ezgif.com-optimize.gif?raw=true)

We have `u8`, `u16`,`u32`,`u64`,`u128` and `u256` each with its specific range of values it can hold. the number following the letter ‘u’ represents the number of bits available for storage. Remember Higher the bits, the larger the value that can be stored.

1. `u8`: This type can store numbers from 0 to 2^8 - 1 || which equals 0 - 255.
2. `u16`: This type can store numbers from 0 to 2^16 - 1 || which equals 0 - 65535
3. `u32`: This type can store numbers from 0 to 2^32 - 1.
4. `u64`: This type can store numbers from 0 to 2^64 - 1.
5. `u128`: This type can store numbers from 0 to 2^128 - 1.
6. `u256`: This type can store numbers from 0 to 2^256 - 1.

Okay, I know that’s a lot to memorize but don’t worry we will help you understand the application of these data types! With that excitement, let’s quickly see an example. 

```
module metaschool::unsigned_integers
{
    use std::debug as bug;
    
    fun sample_function(){
        let myU8: u8;
        myU8 = 200;
        bug::print(&myU8);
    }
}
```

Here, we have an unsigned integer `u8` variable. The '`8`' in `u8` represents the number of bits available for storage. With 8 bits, the largest value we can store is 2 to the power of 8, which equals 256. However, since we start counting from 0, the largest value we can store in `u8` is 255.

Now what if we store a value greater than 255?

```
 fun sample_function(){
        let myU8: u8;
        myU8 = 300;
    }
```

Here, we are storing a larger value such as 300, in the `myU8` variable. In this case, MOVE's type system steps in to ensure data integrity. It recognizes that 300 exceeds the allowable range for U8 and prevents the assignment, throwing a compilation error.

## Boolean

Next up, we have Boolean. Now, the legendary William Shakespeare once said “to be or not to be”, he unknowingly captured the essence of the boolean data type. This data type represents a binary value of either true or false. 

![bulb.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Enrich%20Your%20dApp%20Using%20Data%20Types/bulb.gif?raw=true)

It's like a switch for a light bulb that can only be on or off, making it one of the simplest yet powerful data types in programming.

```
 fun sample_function(){
       let myBool: bool;
        myBool = true;
        myBool = false;
    }
```

Here, we have declared a Boolean variable called `myBool` using the `let` keyword and specifying the data type with the `bool` keyword. We are then assigning `true` to `myBool`, indicating a positive state. Next, we assign false to `myBool`, representing a negative state. Just like flipping a light switch, Booleans in Move offers a straightforward way to represent binary decisions or states within our programs.

## Addresses

Now, let's talk about the next data type, which is somewhat similar to the address of your home. 

![address-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Enrich%20Your%20dApp%20Using%20Data%20Types/address-ezgif.com-optimize.gif?raw=true)

In the world of blockchain, think of blockchain as the society you live in, where each entity has its unique address, just like your home has a specific address in your neighborhood. It's like having a digital GPS that guides us to specific destinations within the blockchain network.

```
 fun sample_function(){
      	let myAddress: address;
        myAddress = 0x1a2b3c4d5e6f;
        myAddress = @0x2; // same as 0x00000000000000000000000000000002
    }
```

Here, we declare an address variable called `myAddress` using the `let` keyword, specifying the data type using the `address` keyword. We then assign the address as the value to this particular variable, representing a digital location on the blockchain. This address acts as our digital coordinates, allowing us to interact with specific entities like contracts or user accounts within the blockchain ecosystem.

Let’s overwrite the value of `myAddress` with `@0x2`, which is equivalent to `0x00000000000000000000000000000002`. This shows how we can assign values to an address variable in Move, including using hexadecimal notation for addresses.

The address data type is really important in blockchain development, serving as a key tool for accurate communication and transaction handling between different entities.

## Vectors

Remember how the chicks follow a line and move in the form of an array when moving behind their mama? This somehow shows the essence of staying true to their group and never abandoning it. That is how the essence of vectors works. This means the data of the same data types should remain intact which can help form one array instead of creating multiple variables.

![ducklings-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Enrich%20Your%20dApp%20Using%20Data%20Types/ducklings-ezgif.com-optimize.gif?raw=true)

Imagine a scenario where you need to handle a collection of 15 unsigned integers. One way to approach this is by creating 15 separate unsigned integer variables, which can be tedious and cumbersome to manage. This approach not only consumes time but also requires keeping track of numerous variables.

This is where Vectors come in handy. Vectors are special because they're the only basic way to collect a bunch of the same type of things. 

A few important things to remember about Vectors is that it is a Homogenous Collection, meaning that it will only store data of the same type. For example, if you create a vector of type `u8` then it will only store values of that particular type, making them efficient and easy to work with. It is also able to grow or shrink dynamically in size so that you can store as many values as needed.

You can create a vector using the `vector` literal. First, let’s import the vector module into our module and simply use the `vector` keyword followed by the desired data type. 

```
module metaschool::vector_example
{
    use std::vector;

    fun sample_function(){
      let v1:vector<u64> = vector<u64>[];
    }
}
```

This creates a mutable Variable `v1` of type vector`<u64>` without any values inside. But what if you want to initialize the Vector during declaration? 

```
    fun sample_function(){
      let v1:vector<u64> = vector<u64> [10,20,30];
      bug::print(&v1);
    }
```

All you need to do is specify all the values to be present within the vector `v1` inside of `[]` separated by commas.

If you wanna modify the Vector, as in maybe insert or remove values from it then, in that case, we have a bunch of functions that can be used from the `std::vector` module, for example, `empty()`, `push_back(v: &mut vector<T>, t: T)`, `swap<T>(v: &mut vector<T>, i: u64, j: u64)`, etc.

## Strings

Well, Let’s say you wanna store your name or a random sentence, OK so which data type should we go for? the data we are trying to store is a sequence of characters called a String and this is kinda of where things get interesting. Move doesn't have a native type specifically for handling strings like some other languages do. You might be wondering, "What's up with that?”

Think of it like this: Imagine you're trying to store your favorite song lyrics in a tiny box. But oh no, the box is too small to fit all the words in! That's kind of how Move feels about strings – it's all about being efficient and focused on blockchain tasks, so it doesn't have a dedicated space for long chunks of text.

![music-box-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Enrich%20Your%20dApp%20Using%20Data%20Types/music-box-ezgif.com-optimize.gif?raw=true)

But fear not! We have two tricks up our sleeve to work with strings in Move:

### Using the `string` Module

It's like bringing in a magic toolbox that can handle strings effortlessly. You can import the `string` module and use the `String` type along with the `utf8` function to create and manipulate strings. For example:

```
use std::string::{String, utf8};

fun greeting(): String {
    let greet: String = utf8(b"Welcome to Move Programming!");
    return greet;
}
```

### Using `vector<u8>` for Byte Strings

If you prefer a more hands-on approach, you can think of strings as a series of bytes, like a secret code where each letter is represented by a number. You can use the vector<u8> type to store byte strings. For example:

```
let byte_string: vector<u8> = b"Hello, world!";
```

## Let’s understand where we used data types in the `calculator`

We have already used some data types in our calculator dApp. Let’s see where we used them.

```
module metaschool::calculator {

		// Rsource with key ability
    struct Calculator has key {
        result: u64,
    }

    fun create_calculator(account: &signer) acquires Calculator {
        if (exists<Calculator>(signer::address_of(account))){
        
		        // Defining calculator variable using let keyword
            let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
            
            calculator.result = 0;
        }
        else {
        
	        // Defining calculator variable using let keyword
	        let calculator = Calculator { result: 0 };
	        
	        move_to(account, calculator);
        }
    }
}
```

In our calculator contract, we defined the `result` field of type `u64`. For now we are using only one data type in our `calculator` module. 

## That’s a wrap

In this lesson, we covered various examples. Try running using the Move CLI. Here's what you can do: create a new package named `examples` and then create different modules such as `integers`, `strings`, `vectors`, and `addresses`. 

Integers, boolean values, strings, vectors, and addresses are the primary data types that you will use frequently when using Move. These data types will assist you in constructing the foundations and beginning to program your first application. Following that, we will delve into the different operators and how we can perform different tasks in the Move programming language.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/4.%20Variables%2C%20Constants%2C%20and%20Functions%20in%20Move/2.%20Enrich%20Your%20dApp%20Using%20Data%20Types.md

Enrich Your dApp Using Data Types

# Let’s Make Our Calculator to Function

Alright, our calculator dApp, though simple, can perform a bunch of algebraic operations. But cramming all that code into one place? That’s a recipe for a headache!🤯 It would be like trying to find a needle in a haystack if something goes wrong. That’s where functions come to the rescue. They help us chop our code into bite-sized, manageable pieces, making it a piece of cake to read, understand, and fix. So, let’s dive in and start slicing and dicing our code!

## What is a Function?

A function in Move is a block of code that performs a specific task. Call a function and it does its magic and gives you an output with or without an input as per the requirement. Functions help keep your code organized, modular, and easy to manage. Our calculator has a bunch of specific algebraic operations to take care of, So we will be making separate functions for each and every other operation. Let’s see how you can create and take complete advantage of modular programming.

![penguin.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Adding%20Functions%20to%20our%20dApp/penguin.webp?raw=true)

## Function declaration

Firstly, in Move, you can define a function using a `fun` keyword. It looks something like this -

```
fun <function_name> (<parameters_list>): <return_type_if_any> {
	<function_body>
}
```

You can define the list of parameters your function will take and also optionally, if you want to return a particular type of output.

## Function call

One thing you need to remember about the function is that to execute the function, you need to call the function. And how do you do that? 

To call the function, the name should be followed by parenthesis `()`. Let’s take an example of add function `add`. You can call this function using `add()` like below: 

```
module examples::function
{
    use std::debug as bug;

    fun add(){
	    // code goes here
    }
    
    fun call_add_function() {
	    add(); // Calling add function
    }
}
```

## Function arguments

You can imagine the function arguments like the number you press to get a particular item say chips from a vending machine. For the `add` function, you if want to add two numbers 5 and 10, you would pass them as an argument as long as it supports adding two numbers. Let’s take a look at the example below which does exactly that.

```
module examples::function
{
    use std::debug as bug;

    fun add(number_1: u8, number_2: u8){
        // function code goes here
    }
}
```

## Function return

Now, how do we return a value from the function? To do so we **DON’T** need a `return` keyword in Move. We write an expression, a variable name, and a function name that returns any value without any other keyword at the end of the function. Let’s look at this coding example.

```
module metaschool::Demo {
    use std::debug as bug;

    fun add(number_1: u8, number_2: u8): u8 {
        // function code goes here
        number_1 + number_2
    }

    fun call_add_function() {
        let result = add(5, 10);
    }
}
```

Here, the `add` function returns the value of `number_1 + number_2` of type `u8` which is then stored inside of the result. 

We can also return multiple variables in Move. To do so, we concatenate all data types in brackets and use commas to separate them. Let’s look at this example.

```
module metaschool::Demo {
	use std::debug as bug;
    fun add(number_1: u8, number_2: u8) : (u8,u8,u8) {
        (number_1 + number_2, number_1*number_2 , number_2 - number_1)
    }

    fun call_add_function() {
        let (sum, product, diff) = add(5, 10);
        bug::print(&sum);
        bug::print(&diff);
        bug::print(&product);
    }
}
```

Here, we defined multiple return types inside of the parenthesis and then returned multiple data using the parenthesis again. This type of syntax where we concatenate multiple values inside of the brackets is also known as tuple notation.

## Let’s make our calculator function

Just as we mentioned at the start, our calculator will perform multiple algebraic operations. To keep things organized, we’ll create individual functions for each operation. To make sure you can follow along easily, we've prepared a boilerplate along with the frontend for you to use. Dive in and let's get coding!

1. First lets switch our boilerplate.
    ```
    git checkout boilerplate_03
    ```
   You will notice that the module name `calculator` is updated to `calculator_l12` in both `calculator.move` and `Move.toml`, this is because we have already deployed our previous contract with module name `calculator`, and we cannot deploy the contract again with the same name.
    
    
2. Open the folder using VS code and you can now start coding in this pre-configured move file.
    
    ![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Adding%20Functions%20to%20our%20dApp/Untitled.webp?raw=true)
    

Let’s kick things off with a function that won’t do any heavy lifting in terms of number crunching, but it's crucial for our frontend. This function, called `get_result()`, will simply return the value of the result field back to our frontend. So let’s add this function into our move file

```
fun get_result(account: &signer): vector<u8> acquires Calculator {
    let calculator = borrow_global<Calculator>(signer::address_of(account));
    calculator.result
}
```

- We're defining a function named `get_result` using the `fun` keyword.
- The function takes one parameter: `account`. It is a parameter of type `&signer`, which represents the account performing the operation. We need this to ensure authorization and authentication for accessing the calculator's data.
- We use the `acquires` keyword to indicate that this function will acquire the `Calculator` resource during its execution. This ensures exclusive access to the `Calculator` resource while the function is running, preventing potential data corruption.
- We use the `borrow_global()` function to get an immutable reference to our `Calculator` resource associated with the account.
- We retrieve and return the `result` field from the `Calculator`.

Alright! It’s time to dive into the main action, starting with the `add()` function. This nifty little function will take two numbers (operands) and return their sum. Now, since we haven’t covered operators yet, we’ll get a bit creative and set the value of `result` to a string for now. Oh, and don’t miss the little tweak: we’ve changed the datatype of `result` to `vector<u8>` to store those fancy strings.

```
fun add(account: &signer, num1: u64, num2: u64) acquires Calculator {
    let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
    calculator.result = b"I am addition function";

    get_result(account);
}
```

Let’s break down this function definition a bit : 

- We're creating a function named `add` using the `fun` keyword.
- This function takes three parameters:
    1. `account`: A parameter of type `&signer` to represent the account performing the operation.
    2. `num1`: A `u64` parameter that represents our first operand.
    3. `num2`: A `u64` parameter that represents our second operand.
- The `acquires` keyword indicates that this function will acquire the `Calculator` resource during its execution. This ensures that no other function can modify the `Calculator` resource concurrently, preventing potential data corruption.
- We use the `borrow_global_mut()` function to get a mutable reference to our `Calculator` resource associated with the account so that we can modify the `result` field.
- We then set the value of `result` to a constant string value: "I am addition function".
- Finally, we call the `get_result()` function to return the value of `result`.

Now, let’s keep the momentum going by following the same pattern and creating functions for the remaining operations. Each function will set the result to a string based on the operation we want to perform. The final code should look somewhat like this.

```
module metaschool::calculator_l12 {
    use std::signer;

    struct Calculator has key {
        result: vector<u8>,  // Result will be of type string 
    }

    fun create_calculator(account: &signer) acquires Calculator {
        if (exists<Calculator>(signer::address_of(account))){
            let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
            calculator.result = b"";  
        }
        else {
            let calculator = Calculator { result: b"" };
            move_to(account, calculator);
        }
    }

   fun add(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am addition function";

        get_result(account);
    }

   fun subtract(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am subtraction function";

        get_result(account);
    }

	fun multiply(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am multiplication function";

        get_result(account);
    }

  fun divide(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am division function";

        get_result(account);
    }

  fun power(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am power function";

        get_result(account);
    }

  fun get_result(account: &signer): vector<u8> acquires Calculator {
        let calculator = borrow_global<Calculator>(signer::address_of(account));
        calculator.result
    }
}

```

## That’s a wrap

Functions are the building blocks of any programming language and is the key to writing efficient and organized code. Next up, we’ll dive into Visibility specifiers for functions, which give us the power to control where our functions can be accessed from. Because, let’s face it, if you try interacting with the dApp in its current state, your frontend will be left hanging. Stay tuned, and let’s figure out how to fix this in the next lesson!👋


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/4.%20Variables%2C%20Constants%2C%20and%20Functions%20in%20Move/3.%20Adding%20Functions%20to%20our%20dApp.md

Let’s Make Our Calculator to Function

# Understanding Visibility Specifiers for Functions

As developers, we're the architects shaping the operations within our blockchain applications. However, just like a master architect designing a complex structure, we must carefully decide who can access specific functions.

All of the functions we had created in the previous lesson like `add()` , `subtract()`, `multiply()`, `divide()`, `power()`, and `get_result()` are currently private by default. That’s just how it works in Aptos Move, unless we explicitly specify the visibility of a function they will stay private , meaning they can’t be accessed outside of our module. so we need to make our front-end 📱to be able to summon these functions.

![calcu-ezgif com-resize](https://github.com/0xmetaschool/Learning-Projects/assets/130544719/db524e1a-a6c6-4c97-8012-07d76340c081)


To address this, Move provides us with visibility specifiers— a tool to precisely control where functions can be executed and who has the authority to call them.

## Private visibility

By default, functions are private, meaning they can only be accessed by other functions within the same module. It’s like a locker in a bank, which can be accessed only by the person who owns it.  Let me show you an example:

```
module maths::multiplication {
    fun return(): u64 {
        42;
    }
}

module maths::call {
		use maths::multiplication;
		
    fun call_maths_package(): u64 {
        maths::multiplication::return(); // ERROR
    }
}
```

Here, the `return` function is private by default, so it's like a private room that only the `multiplication` module can access. Here’s a diagram for you to understand this better.

![Group 15.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Understanding%20Visibility%20Specifiers%20for%20Function/Group_15.webp?raw=true)

Notably, functions within a module are set as private by default. This helps to keep code organized and maintainable. You don't need to use a specific keyword to declare them as private, which can save time when writing code.

## Public visibility

You can use the `public` keyword to make a function public. Public functions are accessible from outside the module, meaning other modules can call these functions. Let me add a public function to our last example:

```
module maths::multiplication {
		public fun multiply(value: u64): u64 {
        value * 2;
    }
}
```

By putting the `public` keyword before the `fun` keyword, we've made the `multiply` function public. Isn't that so easy?

Keep in mind that the following entities can call public functions:

1. other functions declared in the same module
2. functions defined in another module
3. the functions defined in the script

Let’s look at a complete example to understand the above points.

```
module maths::multiplication {
		public fun multiply(value: u64): u64 {
        value * 2;
    }
    
    fun return(): u64 {
        42;
    }
}

module maths::addition {
		public fun add(value: u64): u64 {
				let res : u64 = maths::multiplication::multiply(value);
        res + value + 2;
    }
}

module maths::call {
		use maths::multiplication;
		use maths::addition;
		
    fun call_maths_package(value: u64): u64 {
        maths::multiplication::multiply(value); // VALID
        maths::addition::add(value); // VALID
        maths::multiplication::return(); // ERROR
    }
}
```

Here, the `multiplication` module has a `public multiply` function, and the `addition` module has a `public add` function that calls the `multiply` function from the `multiplication` module. Similarly, the `call` module calls both `multiply` and `add` functions. Here’s a diagram for you to understand this better. 

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Understanding%20Visibility%20Specifiers%20for%20Function/Untitled.webp?raw=true)

## Public(friend) visibility

The `public(friend)` modifier is a bit more of a restricted form of the public visibility modifier. This helps increase the security of the functions and control where the functions can be used. Let's see where `public(friend)` functions can be called:

1. other functions inside of the same module
2. functions defined in modules that are explicitly specified using the friend keyword.

Let’s look at the detailed example.

```
module maths::multiplication {
		friend maths::addition; // friend declaration
		
		public(friend) fun multiply(value: u64): u64 {
        value * 2;
    }
    
    fun call_addition(value: u64): u64 {
	    maths::addition::add(value); // VALID
    }
}

module maths::addition {
		public fun add(value: u64): u64 {
				let res : u64 = maths::multiplication::multiply(value); // VALID
        res + value + 2;
    }
}

module maths::subtraction {
		public fun sub(value: u64): u64 {
				/* The following line will throw an error as the subtraction module is not
				   a friend of the multiplication module. */
				let res : u64 = maths::multiplication::multiply(value); // ERROR
        value - 2;
    }
}

module maths::call {
		use maths::multiplication;
		use maths::addition;
		
    fun calls_maths_package(value: u64): u64 {
        maths::multiplication::multiply(value); // ERROR
        maths::addition::add(value); // VALID
    }
}
```

Let’s understand the code in detail.

1. Inside the `multiplication` module, we imported the `addition` module using the `friend` keyword and called the add function inside of the `call_addition` function, which is a valid call.
2. Inside the `addition` module, we are calling the `multiply` function which is a valid call because we imported the `addition` module inside of the `multiplication` module using the `friend` keyword. This means the `multiplication` module can call the `addition` module functions and the `addition` module can call the `multiplication` module functions.
3. Thirdly, we defined the `subtraction` module which tries to call the `multiplication` module. Here, the code will throw an error because the `subtraction` module is not a friend of the `multiplication` module.
4. Lastly, we are defining a `call` module that again tries to call the `multiplication` module. We will face an error again here as the `call` module is not a friend of the `multiplication` module.

Here’s the diagram to understand this better.

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Understanding%20Visibility%20Specifiers%20for%20Function/Untitled%201.webp?raw=true)

## Entry functions

Alright people, listen in and heed my words. This is a really important concept you need to be aware of when it comes to Move, so, buckle up! There is a special type of function in Move which serves as the entry point for external entities like users, other smart contracts, or even off-chain applications to interact with the blockchain. 

These functions are designated as entry points because they are accessible from outside the blockchain network, allowing external users or other smart contracts to invoke and interact with the functionality provided by the Move code.

In Move, one of the basic operations is transferring gas objects between addresses representing individual users. When you make a transaction, the `entry` function is called directly. It's like the main entrance to a party! To create an `entry` function, we need to follow these three rules.

1. The function should be marked by the `entry` keyword.
2. It should have no return value.
3. It is compulsory to pass the `&signer` as an argument to the entry functions.

Let me show you an example from our first contract program:

```
module hello_world::msg {
    use std::signer;

    struct Message has key {
        value: vector<u8>
    }

    public entry fun set_message(account: &mut signer, msg: vector<u8>) {
        move_to(&account, Message { value: msg });
    }
}
```

In this example, the `set_message` function is an entry function marked with the `entry` keyword. It takes a `&mut signer` as the last parameter, which identifies the caller who wants to store a message. The function has no return value, and it uses `move_to` to store a `Message` object containing the provided `msg` vector under the caller's account in global storage.

This is a simple example of an entry function that allows users to store a message on the blockchain. Pretty cool, right? Entry functions are like the party entrance, allowing users to interact with your Move module and make transactions.

**Note:** Adding `&` with the function input means we are passing the argument by reference, meaning the variable refers to the memory address of the original value. And adding `&mut` with the variable means you can change the value of the memory address the variables refer to.

## Entry functions vs Public functions

So, what's the difference between entry functions and public functions? Well, public functions can be called from other modules, but they don't necessarily interact with the blockchain or make transactions. Entry functions, on the other hand, are specifically designed to be called when making a transaction on the blockchain.

Entry functions require special `&mut signer` parameters to identify the caller and allow them to make changes to the blockchain state. Public functions don't have this requirement and can be called from other modules for various purposes, such as performing computations or accessing data.

## Making our code Functionally Accessible

Time to make our functions accessible by granting them the necessary permissions. Our goal is to enable our React frontend app to call these functions from outside the Aptos blockchain, allowing access from anyone, anywhere.

We will be making all the function to be both `public`and `entry` function except the`get_result()` function which doesn’t need to called from our frontend, so we will be keeping the `get_result()` just `public`. This is how the final code will look like.

```
module metaschool::calculator_l12 {
    use std::signer;

    struct Calculator has key {
        result: vector<u8>,  // Result will be of type string 
    }

    public entry fun create_calculator(account: &signer) acquires Calculator {
        if (exists<Calculator>(signer::address_of(account))){
            let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
            calculator.result = b"";  
        }
        else {
            let calculator = Calculator { result: b"" };
            move_to(account, calculator);
        }
    }

    public entry fun add(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am addition function";

        get_result(account);
    }

     public entry fun subtract(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am subtraction function";

        get_result(account);
    }

    public entry fun multiply(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am multiplication function";

        get_result(account);
    }

    public entry fun divide(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am division function";

        get_result(account);
    }

    public entry fun power(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = b"I am power function";

        get_result(account);
    }

    public fun get_result(account: &signer): vector<u8> acquires Calculator {
        let calculator = borrow_global<Calculator>(signer::address_of(account));
        calculator.result
    }
}
```

Let’s get this code published to the Network. So much like last time, we need to setup our Aptos CLI first and then publish our code. But first, let's quickly swap out our boilerplate with the corresponding frontend for these functionalities. 

```
git checkout origin/boilerplate_03
```

1. In the `Building-on-Aptos-boilerplate` directory, run the following command: 
    ```
    aptos init
    ```   
2. Skip this step if your wallet is already configured. Type in “testnet” for your network and provide your Private key when prompted. 
3. Edit the `Move.toml` file by adding your Wallet address against `metaschool`:
    ```
    metaschool = "<Enter-your-wallet-address-here>"
    ```
4. Paste the complete code in `sources/calculator.move`.
5. Compile the code using the following command:   
    ```
    aptos move compile --skip-fetch-latest-git-deps
    ```
6.  Now, deploy the code using the following command:  
    ```
    aptos move publish --skip-fetch-latest-git-deps
    ```
    

## Let’s smash some more buttons

Let’s try out our current dApp using the frontend:

1. Change the directory to the `interface` folder:
    
    ```
    cd ./interface
    ```
    
2. With the terminal still in the `interface` directory, install all the necessary dependencies by running:
    
    ```
    npm install
    ```
    

You can ignore the warning generated in the terminal. Once done you should be able to find a `.env` file in your `interface` folder and it would look something like this:

```
REACT_APP_MODULE_ADDRESS = "<Enter-your-wallet-address-here>"
REACT_APP_MODULE_NAME= "calculator_l12"
```

Replace your Petra wallet address with `<Enter-your-wallet-address-here>`. And now we are all set, Finally set sail and deploy our react App by running.

```
npm start
```

Here’s how the dApp will look in your browser. Turn on the calculator and try some algebraic operations. While it won't crunch any numbers just yet, it will greet you with a message based on the operation you've performed😉.

![tres.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Understanding%20Visibility%20Specifiers%20for%20Function/tres.webp?raw=true)

## Pushing it to Git

Make sure you are in `Building-on-Aptos-boilerplate` folder. If you are in `interface` folder just run `cd ../` to return to the previous directory. Push your code to your GitHub repository using the following commands. 
```
git add .
git commit -m "code update"
git push
```

## That's a wrap

Function visibility and entry functions play a crucial role in Move. Now, Let’s dive deeper into Move and learn about friends as we mentioned in this lesson. It's time for us to explore a whole new dimension of awesomeness, my friend!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/4.%20Variables%2C%20Constants%2C%20and%20Functions%20in%20Move/4.%20Understanding%20Visibility%20Specifiers%20for%20Function.md

Understanding Visibility Specifiers for Functions

# Introduction to Operators

Well, the whole point of a programming language is to help you 🫵, The Developer, manipulate data and perform a series of operations to achieve the results you want. Whether you're building a simple calculator or a complex application, operators are the fundamental tools that make it all possible.

In the case of our calculator dApp, we need it to perform basic arithmetic operations like addition, subtraction, multiplication, and division. These operations are the backbone of any calculator, and understanding how to implement them using operators in Move is crucial.

## Operators in Move

Much like every other programming, Solidity has a special set of symbols called operators that can be used to perform specific operations on data. Depending on the type of data that these operators work on and operation that they do, we can categorize these operators onto following types. 

1. **Arithmetic Operators**
    
    These are the go-to operators for basic math, just like you use in everyday calculations. They work on numerical data types, such as `uint`, `int`, and `uint256`.
    
    ![Slide9.PNG](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Introduction%20to%20Operators/Slide9.webp?raw=true)
    
2. **Relational Operators**
    
    These help you compare values to see how they relate. They work on numerical data types (`uint`, `int`, `uint256`) and also on `bool` types for equality and inequality checks. We will be needing them soon enough in the upcoming lessons.
    
    ![Slide10.PNG](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Introduction%20to%20Operators/Slide10.webp?raw=true)
    
3. **Logical Operators**
    
    These are like the logical words you use in everyday conversation, helping you decide based on multiple conditions. They work on `bool` types.
    
    ![Slide11.PNG](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Introduction%20to%20Operators/Slide11.webp?raw=true)
    
4. **Bitwise Operators**
    
    These work with the individual bits (0s and 1s) in your data. They operate on `uint`types.
    
    ![Slide12.PNG](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Introduction%20to%20Operators/Slide12.webp?raw=true)
    
5. **Assignment Operators**
    
    These are used to assign values to your variables or change their current values. They work on numerical and Boolean data types.
    
    ![Slide13.PNG](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Introduction%20to%20Operators/Slide13.webp?raw=true)
    
6. **Conditional Operators**
    
    This is a shorthand for if-else statements. It works on any data types that can be evaluated in a condition. A compact way to return one of two values based on a condition. It uses the syntax 
    
    ```
    condition ? valueIfTrue : valueIfFalse
    ```
    

Most of these operators work similarly to how they do in other programming languages, making them easy to understand and use if you're already familiar with languages like JavaScript, C++, or Python. We're mostly just listing these operators out to show their specific applications in Move.

## Code Makeover: Adding Operators

Alright, let's tweak our code to make sure it’s crunching the right numbers in all our functions. First things first, we need to change the data type of the result we're returning.

In the previous lesson, we set the `result` field as `vector<u8>` to handle strings. But let's be real, a calculator that doesn't return numbers is like a keyboard without keys, pretty useless!😅 So, let's update that to `u64` so we can return a number. Because, after all, we want our calculator to be number one at returning numbers, right?

```
struct Calculator has key {
   result: u64, // Result will be of type u64
} 
```

Now, let's focus on our `add()` function. We're going to put the `+` operator to work and sum up both of our function parameters. This will set the value of `result` to their total.

```
public entry fun add(account: &signer, num1: u64, num2: u64) acquires Calculator {
    let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
    calculator.result = num1 + num2; // updating value of result field

    get_result(account);
}
```

First, it gets a mutable reference to our `Calculator` struct using the account's address. Then, it sums `num1` and `num2` with the `+` operator and updates the `result` field with this value. Finally, it calls `get_result(account)` to fetch the updated result. And just like that, our calculator is ready to add things up!

## That’s a Wrap

Great job! In this lesson, we learned how to update our code to handle numerical results by changing the `result` field to `u64`, and we used the `+` operator in the `add()` function to sum values and update the result. With these skills, your calculator Dapp is on its way to becoming a fully functional number-crunching machine. Now, try to define the `multiply` function by yourself. You’ve got the basics down, so go ahead and put your new knowledge to the test.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/5.%20Operators%20and%20Control%20Flow%20in%20Move/1.%20Introduction%20to%20Operators.md

Introduction to Operators

# Edge-case Ninjas in Action

Welcome back, folks!! Last time, you dove into the world of operators and successfully integrated them into your calculator dApp. Way to go!

In this lesson, we're going to unravel the magic of if and else conditions. You've already added these to your calculator dApp, but now, let's take a closer look to see how they really work and why they're so powerful. Let's get started!

## Control statements

Move gives you access to control statements that allow you to perform operations based on the condition. Think of control statements as the traffic signals in a busy intersection. They help direct the flow of traffic or in our case, code execution based on certain conditions.

For example, you want to buy a bar of chocolate but you decide if the chocolate has sugar you will not buy it and if it doesn’t you will buy it. Here, you put the conditions on your buying statement. Same as this we use control statements to put the condition before doing certain tasks. For example, if `num_1` is equal to 10 and `num_2` is equal to 20 then we will add these numbers otherwise we will subtract them.

![fig-gif-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Edge-case%20Ninjas%20in%20Action/fig-gif-ezgif.com-optimize.webp?raw=true)

## `if` statement

The last example we discussed can be achieved quite easily by using the `if` expression. The `if` expression is like a Swiss army knife when it comes to functionality and is useful in many scenarios. Let us demonstrate.

The basic working of an **`if`** expression is quite simple. It's as simple as saying “If it’s Sugar-free, then I will buy it”. The `if` expression specifies that some code should only be evaluated if a certain condition is true. The basic syntax goes like this.

```
 if ( boolean-expression )
 {
	 // true-branch
 };
```

The `if` statement is followed by a condition, generally a Boolean expression. This is exactly where the logical, equality, and comparison operators i.e. relational operators (`&&`, `||`, `<`, `>`, `==`, `!=`) we discussed in the previous lessons will come in handy. Relational operators will always give a boolean value in return after evaluation. If the Boolean expression is evaluated as true then the branch of code specified in the scope of the `if`-expression will be executed. 

Let’s take an example to understand this better.

```
module example::if_statement
{
    use std::debug as bug;
    fun sample_function(){
    
        let a : u8 = 15;
        if(a == 15)
        {
            a = a + 5;
        };
        bug::print(&a);
    }
}
```

In this example, we have the `if` keyword followed by a Boolean expression which checks if the value of variable `a` is equal to `15` or not. For this example the value initialized to variable `a` is `15` so the expression inside the scope of the `if`-statement will execute, incrementing the value of variable `a` by 5. The code will give the `20` output.

But if the condition is not true, then in that case block of code will not be executed. For example:

```
module example::if_statement
{
    use std::debug as bug;
    fun sample_function(){
        let a : u8 = 15;
        if(a == 5)
        {
            a = a + 5;
        };
        bug::print(&a);
    }
}
```

In this code, we are checking if the value of the variable `a` is 5. But as the value initialized to **`a`** is not equal to 5, our condition is false. So the block of code will not be executed. And the value of a will NOT be incremented by 5. This code will print `15`.

## `else` statement

If there’s a requirement to perform some operations when the condition is false then the `else` clause comes in handy. The `else` **clause contains the branch of code to be executed when `if` the condition is false. 

![Group 14.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Edge-case%20Ninjas%20in%20Action/Group_14.webp?raw=true)

The `else` has to be used along with the `if` statement or else we will be gifted with an error right on the spot.

```
if(false-condition)
{
	// false branch
}
else
{
	// true branch
};
```

Let’s try it out in our previous code. Here I have added the `else` clause to set the value of variable ‘`a`’ to 0 if the condition is false. 

```
module example::if_statement
{
    use std::debug as bug;		
    fun sample_function(){
        let a : u8 = 15;
        if(a == 5) // false condition
        {
            a = a + 5;
        }
        else
        {
            a = 0;
        };
        bug::print(&a);
    }
}
```

The code will print the `0` output.

The conditional expressions can produce values if needed, i.e. it can return a result. This comes especially handy if you want to initialize a value to a variable based on a condition. For example, 

```
module example::if_statement
{
    use std::debug as bug;	
    fun sample_function(){
        let a:u8 = 5;
        let b:u8 = 10;
        let c = if (a < 100) a else b;
        bug::print(&b);
    }    
}
```

Let’s swap out the expression for values, We will change the true branch to give out variable `a` and the false branch to `b`. The value of variable `c` is assigned based on the condition of whether the value of `a` is less than 100 or not. As the value of the so-called variable is less than 100 then the value assigned to variable `b` will be equal to `a` i.e. it will be equal to 5. So, at last the code will print `10`.

## Code makeover: Adding subtraction and division

Let’s look at the `create_calculator` that we have already built in our `calculator` module, add a division function, and understand how if-else conditions are helping us in the code.

### create_calculator

```
fun create_calculator(account: &signer) acquires Calculator {
    if (exists<Calculator>(signer::address_of(account))){
    
        // Defining calculator variable using let keyword
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        
        calculator.result = 0;
    }
    else {
    
      // Defining calculator variable using let keyword
      let calculator = Calculator { result: 0 };
      
      move_to(account, calculator);
    }
}
```

Let us explain how if-else conditions work in the `create_calculator`  function.

- The if condition here helps us identify if the signer address already has a `Calculator` resource or not. If it does we fetch and modify the result field.
- The else condition helps us create a new resource and move it to the signer address if the signer address already doesn’t have the resource.

### divide

```
public entry fun divide(account: &signer, num1: u64, num2: u64) acquires Calculator {
    use std::error; // import the error from standard module

    let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
    if (num2 == 0) {
        abort error::invalid_argument(0)
    } else {
        calculator.result = num1 / num2;
    };

    get_result(account);
}
```

Here, we are again fetching the `Calculator` resource from the signer's address first then using the condition to check if the `num2` given is equal to `0` or not. Because if it is equal to `0` then the division is not possible and we abort.

## That’s a wrap

That’s all folks!! It is very important to get familiar with conditionals because they always come in handy. You want to check if the number is even or odd using conditionals or you want to assign value to a variable only if the value is even, you’ll need to work with the conditionals.

Try running all the examples mentioned in this lesson on your system and check the output. See what you get. 


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/5.%20Operators%20and%20Control%20Flow%20in%20Move/2.%20Edge-case%20Ninjas%20in%20Action.md

Edge-case Ninjas in Action

# Transform Your dApp Using Loop Scoop

Hey there, welcome back! Last time, you got the hang of control statements and how they help you tackle all those tricky edge cases. Now, we're going to dive into loops and see how they can help us implement the power function in our `calculator` dApp.

Ever heard the saying, "Work smarter, not harder"? Well, loops in coding are like your personal smart assistant—they take care of repetitive tasks so you can focus on the fun stuff.

Picture this: you’ve got a bunch of tasks that need to be done over and over again. Throw them into a loop, and voila, your code does the heavy lifting while you sip your coffee.

In this lesson, we're diving into loops in Move programming. But wait, there's more! We'll also sprinkle in some cool keywords that add extra spice to your loops, making them even more powerful.

![loop.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Transform%20Your%20dApp%20Using%20Loop%20Scoop/loop.webp?raw=true)

There are three loop constructs in Move that we’ll get familiar with:

1. **`while`**: A loop that repeats while a condition is true.
2. **`loop`**: A loop that repeats indefinitely until a break statement is encountered.
3. **`for`**: A loop that iterates over a range of values or a collection.

Let’s explore how each of these works and see them in action with our `calculator` dApp!

## `while` loop

Let’s start with the `while` loop. The ‘`while`’ loop repeats the body until the condition, which is an expression of type bool, evaluates to false. 

```
while(boolean-expression)
{
	// body of the loop
};
```

It’s just the `while` keyword followed by a condition, here again, similar to conditionals we will be using relational operators to define conditions. The While loop will have a block of code within its scope, these are the set of instructions that will be repeated until the condition becomes false. So let’s make a while loop, now we need a condition and a set of instructions to be repeatedly executed until the condition becomes false.

Let’s make our `while` loop to find the sum of the first `n` natural numbers. So we are going to need a variable `n`, a variable to store the sum, and one more variable, let’s call it `i` to track the the natural number we are adding to the sum. 

The value of `i` will start from 1 and should increase till it reaches `n` , so let’s add the condition to the loop that repeats if the value of i is less than equal 

```
module metaschool::Demo
{
    use std::debug as bug;
    fun sample_function(){
        let n = 5; 
        let sum = 0;
        let i = 1;
        while (i <= n) {
            sum = sum + i;
            i = i + 1
        };
        bug::print(&sum);
    }
}
```

 

Here, the `while` loop will repeatedly increment the value of the variable `sum` by the value of `i` until the condition becomes false, i.e., `i` does not become bigger than `n`. 

For the value of `n = 5` then what will the value of the sum after the loop ends?

The Correct answer will be 15. The Loop iterates until the condition becomes false, so for a value of `i = 6`, our Boolean expression will become false as 5 is not less than or equal to 5. So the value of the sum will increment with value `i` which ranges from 1 to 5 so finally sum will be 1 + 2 + 3 + 4 + 5, which equals 15.

## `loop` expression

Next up, we have the `loop` expression. It repeats the loop body until it hits a break. Without a `break` keyword, the loop will continue forever and you’ll have an infinite loop in your hands. 

```
loop {
	// Code
	if(condition) break; // necessary for stopping the loop	
}
```

Let’s take an example, Following is the same program for the sum of n natural numbers we saw in the case of a `while` loop but re-written to use `loop` expression along with `break` keyword.

```
   fun sample_function(){
        let n = 5; 
        let sum = 0;
        let i = 1;
        loop {
            if (i > n) break;
            sum = sum + i;
            i = i + 1;
        };
        bug::print(&sum);
    }
```

Here we are using the `break` keyword to explicitly stop the loop when the condition `(i > n)` becomes `true`. That’s one difference between the `while` and `loop` expressions. The `while` loop ends when the condition becomes false whereas the `loop` expression terminates when the condition becomes true to make the break statement come into play to stop the lopping.

Finally, Move loops are typed expressions. A `while` expression and `loop` expression containing a break will always have type as `()`. If the `loop` does not contain a `break`, the `loop` can have any type.

```
let () = while (i < 10) { i = i + 1 };

let () = loop { if (i < 10) i = i + 1 else break };
```

Let’s see a quick example.

```
fun sample_function(){
        let i: u8 = 0;
        let () = while (i < 10) { i = i + 1 };
        bug::print(&i);
    }
```

Inside the sample function, we declare a mutable variable `i` and initialize it to `0`. Next, we have a statement that utilizes a `while` loop with an empty block. This loop increments the value of `i` until it reaches 10.

## `for` loop

Finally, we have the good old `for` loop, Unlike the for Loop you might see in other programming languages, The `for` loop in Move is a bit special. it is used specifically in scenarios where you know exactly how many times you want to repeat a certain task. Most commonly used for iterating over a range or collection of values. 

Let’s take the same example back again. Imagine we want to compute the sum of numbers from 0 to n-1. 

```
fun sample_function(){
        let n = 5;
        let sum = 0;
        for (i in 0..n) { // Here, i iterates from 0 to n-1
            sum = sum + i; // Adding each value of i to sum
        };
        bug::print(&sum);
    }
```

In this code, the for loop is your hero. It starts at `0` (`i` is set to `0`), keeps going until it reaches `n - 1` (the upper_bound in the range), and does its thing inside the loop body for each value of `i`.

Now, a little trick – the `break` and `continue` keywords we've seen before can also be used in `for` loops. If you need to jump out of the loop early or skip certain iterations, these keywords have got your back.

## Let’s implement the power function in our calculator

Let's dive into the power function and see how it works with loops in our calculator dApp. To keep things tidy and neat, I'll show you just the power function here. We'll cover the complete code in the next lesson.

![power.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Transform%20Your%20dApp%20Using%20Loop%20Scoop/power.webp?raw=true)

Ready? Let’s get powered up!

```
public entry fun power(account: &signer, num1: u64, num2: u64) acquires Calculator {
  let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
  if (num2 == 0) {
      abort error::invalid_argument(0)
  } else {
      let i = 1;
      calculator.result = num1;
      while (i < num2){
          calculator.result = calculator.result * num1;
          i = i + 1;
      }

  };

  get_result(account);
}
```

Let’s understand what we did here in the code.

- The `power` function takes three arguments: `&signer` and two `u64` numbers.
- First, it checks if the second number is zero. If it is, the program aborts and shows an error to prompt the user for the correct input.
- In the `else` condition, we initialize a variable `i` with the value `1` and assign `num1` to the `calculator`'s `result` field.
- A while loop runs as long as `i` is smaller than `num2` because we need to multiply `num1` by itself `num2` times.
- Inside the while loop, we multiply `num1` by `calculator.result` and store the result back into `calculator.result`. We also increment the `i` variable.
- Finally, outside the if-else condition, we call `get_result(account);`, which retrieves the result for the signer's `calculator`.

Ready for the full code? We'll go through it in the next lesson! Stay tuned, rockstars!

## That’s a wrap

So there you have it, folks! Time to earn some brownie points. Try writing a loop to print all even numbers under 50. It's a fun challenge!

That's it for this lesson. In the next one, we'll compile all the calculator module code in one place, deploy it, and then interact with the frontend. Stay tuned for the grand finale!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/5.%20Operators%20and%20Control%20Flow%20in%20Move/3.%20Transform%20Your%20dApp%20Using%20Loop%20Scoop.md

Transform Your dApp Using Loop Scoop

# Launch Your Calculator on Aptos

Welcome back, folks!! We’re so proud of how far you’ve come in this course. You’re almost at the finish line! In this lesson, we’re going to fully interact with the calculator dApp we've built together.

We’ll revisit how to deploy the dApp to the Aptos testnet and explore its various features.

Finally, we’ll guide you on how to deploy your dApp to the mainnet, so you can launch your amazing creation if you wish. Let’s dive in and bring your dApp to life!

## Complete code 101

Before moving forward let us show you how the complete and final look of the `calculator` module looks like.

```
module metaschool::final_calculator {
    use std::error;
    use std::signer;

    struct Calculator has key {
        result: u64,
    }

    public entry fun create_calculator(account: &signer) acquires Calculator {
        if (exists<Calculator>(signer::address_of(account))){
            let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
            calculator.result = 0;
        }
        else {
        let calculator = Calculator { result: 0 };
        move_to(account, calculator);
        }
    }

    public entry fun add(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = num1 + num2;

        get_result(account);
    }

    public entry fun subtract(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        if (num1 > num2){
            calculator.result = num1 - num2;
            get_result(account);

        }
        else {
            calculator.result = num2 - num1;
            get_result(account);

        }
    }

    public entry fun multiply(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        calculator.result = num1 * num2;

        get_result(account);
    }

    public entry fun divide(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        if (num2 == 0) {
            abort error::invalid_argument(0)
        } else {
            calculator.result = num1 / num2;
        };

        get_result(account);
    }

    public entry fun power(account: &signer, num1: u64, num2: u64) acquires Calculator {
        let calculator = borrow_global_mut<Calculator>(signer::address_of(account));
        if (num2 == 0) {
            abort error::invalid_argument(0)
        } else {
            let i = 1;
            calculator.result = num1;
            while (i < num2){
                calculator.result = calculator.result * num1;
                i = i + 1;
            }
 
        };

        get_result(account);
    }

    public fun get_result (account: &signer): u64 acquires Calculator {
        let calculator = borrow_global<Calculator>(signer::address_of(account));
        calculator.result
    }
}
```

## Set up the project

We have already pushed the complete code with the front end to GitHub for your ease. You just need to set it up in your system. So, follow the following steps to set it up. Run the following command to move to our required branch:
```
git checkout origin/complete_code  
```

## Deploy your dApp to the Aptos Blockchain testnet

1. In the `Building-on-Aptos-boilerplate` directory, run the following command: 
    ```
    aptos init
    ```   
2. Skip this step if your wallet is already configured. Type in “testnet” for your network and provide your Private key when prompted. 
3. Edit the `Move.toml` file by adding your Wallet address against `metaschool`:
    ```
    metaschool = "<Enter-your-wallet-address-here>"
    ```
4. Compile the code using the following command:   
    ```
    aptos move compile --skip-fetch-latest-git-deps
    ```
5.  Now, deploy the code using the following command:  
    ```
    aptos move publish --skip-fetch-latest-git-deps
    ```

## Set up the frontend

1. Change the directory to the `interface` folder:
    ```
    cd ./interface
    ```    
2. With the terminal still in the `interface` directory, install all the necessary dependencies by running:
    ```
    npm install
    ```
    You can ignore the warning generated in the terminal. Once done you should be able to find a `.env` file in your `interface` folder and it would look something like this:
    ```
    REACT_APP_MODULE_ADDRESS = "<Enter-your-wallet-address-here>"
    REACT_APP_MODULE_NAME= "final_calculator"
    ```
3. Replace your Petra wallet address with `<Enter-your-wallet-address-here>`. And now we are all set, Finally set sail and deploy our react App by running.
    ```
    npm start
    ```

## Interact with the frontend

Alright, let’s dive into each feature of the frontend one by one!

1. **First, connect with the Petra wallet:** Hit the “Connect Wallet” button and get connected.
    
    ![interact-1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-1.webp?raw=true)
    
2. **Turn on the calculator:** Click the “Turn On” button to power up the calculator.
    
    ![interact-2.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-2.webp?raw=true)
    
3. **Add two numbers:** Select the first number, press the “+” operator, pick the second number, and then click the equal sign. Approve the transaction to see the result.
    
    ![interact-3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-3.webp?raw=true)
    

4. **Subtract two numbers:** Clear the screen by pressing the “C” button, then perform the subtraction.
    
    ![interact-4.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-4.webp?raw=true)
    
5. **Multiply two numbers:** Now, try out the multiplication feature.
    
    ![interact-5.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-5.webp?raw=true)
    
6. **Divide two numbers:** Give the division function a go.
    
    ![interact-6.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-6.webp?raw=true)
    
7. **Use the power function:** Finally, test out the power function.
    
    ![interact-7.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-7.webp?raw=true)
    
8. **Made a mistake? No problem!** If you enter a wrong digit, just use the “←” button to backspace and correct it.
    
    ![interact-8.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/interact-8.webp?raw=true)
    
## Pushing it to Git

Make sure you are in `Building-on-Aptos-boilerplate` folder. If you are in `interface` folder just run `cd ../` to return to the previous directory. Push your code to your GitHub repository using the following commands. 
```
git add .
git commit -m "code update"
git push
```

## Deploy your dApp to the mainnet

To deploy the dApp to the mainnet, first of all, switch your network to mainnet on Petra Wallet using the “switch to Mainnet” button.

![switch-mainnet.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/switch-mainnet.webp?raw=true)

Then buy some APT tokens because without them you won’t be able to deploy your dApp. Buy the APT tokens with real money.

![switch-mainnet-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/switch-mainnet-2.webp?raw=true)

After buying the tokens head back to `Building-on-Aptos` project folder and run `aptos init` command. Make sure to select “mainnet” as your network and provide a private key when prompted.

![switch-mainnet-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Launch%20Your%20Calculator%20on%20Aptos/switch-mainnet-3.webp?raw=true)

Finally, run the `aptos move publish` command to publish your dApp to the mainnet.

## That’s a wrap

Fantastic job, buddy!! We’re incredibly proud of you!! You’ve developed the calculator dApp, deployed it on the testnet, and even connected it to the frontend.

You’re now ready to create even more dApps on Aptos Move. Great work!! Let’s recap what we’ve learned in this course and wrap things up.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/6.%20Deploy%20and%20interact/1.%20Launch%20Your%20Calculator%20on%20Aptos.md

Launch Your Calculator on Aptos

# 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 and how it can empower you in the world of blockchain development.

## What You Built

A branded MetaSchool calculator dApp on the Aptos blockchain. It had the following key features:

- **Performed basic calculations**: addition, subtraction, multiplication, division, etc.
- **Handled advanced operations**: modulo, power calculation, logical and comparison operators

![interact-3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Let%E2%80%99s%20Wrap%20It%20Up/interact-3.webp?raw=true)

## What We Covered

We covered the following:

- **Introduction:** Got an overview of Aptos, dApps, Move programming language, and the course structure.
- **Understanding Basic Concepts:** We broke down the basics of blockchain, smart contracts, and the Move programming language used for building Aptos dApps.
- **Getting Started with Development:** Learnt how to set up your development environment using the Aptos CLI. You installed the necessary tools, created a wallet, and understood the project structure for your calculator dApp.
- **Building Your Calculator Project:** We wrote the Move code for your dApp. You learned about modules, and directory structure, and deployed your first smart contract.
- **Structuring Your dApp and Adding Resources:** Explored the concept of structs and resources in Move, crucial for building dApps like your calculator. You learned how to define structs and resources and integrated them into your dApp.
- **Variables, Constants, Functions & Control Flow:** You learned how to define variables, constants, and functions with different visibility levels (public/private) for your dApp. We explored operators (arithmetic, logical, comparison) and control flow statements (if/else, loops) to handle user input and calculations.
- **Deploy and Interact:** Learned how to deploy your dApp to the Aptos testnet and interact with it. We discussed the process of deploying to the mainnet.

![Frame 3560405.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/aptos-c2-building-on-aptos-assets/Let%E2%80%99s%20Wrap%20It%20Up/Frame_3560405.webp?raw=true)

## ⚒️ A small yet important request

Here is 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://twitter.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool/) channel for exciting videos. ✨

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 Aptos blockchain. We wish you luck!

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Start%20Building%20on%20Aptos/7.%20Let%E2%80%99s%20Wrap%20Up%20The%20Course/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Start Building on Aptos

This course will teach you all about the token standards in the Aptos blockchain. It will start with teaching you the basics of token standards and then move you to setting up and building the fungible token on the Aptos blockchain. The fungible token will have mint, transfer, burn, deposit, withdraw, freeze, and un-freeze functionalities that will equip you completely with creating a complete fungible token on the Aptos blockchain using Aptos Move. Not only this, you will learn to deploy and interact with fungible tokens so that you can perform all the functionalities in real-time.

# What Are We Building Today

GM everyone! ☀️ We’re super excited to kick off the third course in our detailed series on Aptos for developers here on Metaschool. First things first, let’s give you a big round of applause for completing the first two courses on Metaschool Woohoo! 🎉

Did you know? Active participants in blockchain communities often stumble upon unexpected rewards. It all starts with staying engaged – like following [Aptos' repos](https://github.com/aptos-labs) on GitHub.

![Frame 3560413.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%201%20Getting%20Started/Lesson%201%20What%20Are%20We%20Building%20Today/Frame_3560413.gif?raw=true)

Aptos is a layer-1 blockchain with **3.9M+** monthly active users and **983M+** transactions as of the writing date. Aptos has over **170+** projects ranging in various domains like DeFi, NFT Tooling, Gaming, Wallets, Stablecoins, Marketplaces, and many more. We know that your project has to be the one on Aptos too and we're thrilled to help you build on this platform. 

We have already talked about features like the resource-oriented structure, Block STM, Aptos Standards, and the Move programming language, and we built a Calculator dApp in our first two courses. Now it’s time to build a fungible token and learn to interact with it. Just for your excitement, we have added a GIF that shows how we will interact with our token. Yesss~

![atpos01.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%201%20Getting%20Started/Lesson%201%20What%20Are%20We%20Building%20Today/atpos01.gif?raw=true)

## The Aptos Move Token Contract

But why build a token contract, you ask? Buckle up, because here's why:

- **Hands-on Learning:** Writing a contract is an engaging and practical way to grasp Aptos blockchain concepts like Aptos Fungible Asset Standard.
- **Deployment and Interaction:** The excitement doesn't stop at coding! You'll deploy your contract onto Aptos, interact with it on the Explorer, and see your code come to life in a decentralized environment.

### Features of the token contract

This course will equip you with the knowledge and skills to build the **following functionalities** of a token contract on Aptos Move:

- **mint:** Creates new tokens of a specific type.
- **transfer:** Sends existing tokens from one account to another.
- **burn:** Destroys existing tokens, taking them out of circulation.
- **deposit:** Moves tokens from a temporary holding area to a permanent storage account.
- **withdraw:** Moves tokens from a permanent storage account to a temporary holding area.
- **freeze_account:** Disables deposits and withdrawals for a specific fungible asset type in an account.
- **unfreeze_account:** Enables deposits and withdrawals for a previously frozen fungible asset type in an account.

## Course Overview

We will:

1. A quick run through the Aptos Fungible Asset Standard.
2. Get your tools and workspace ready for development.
3. Build the foundations of the contract
4. Add functionalities like mint, transfer, burn, withdraw, and more
5. Deploy and Interact with the Token Contract on Aptos Testnet Explorer

## Who exactly should take this course?

This course is for beginner level Web3 developers who wish to learn about Aptos and have completed our first two courses on Aptos. 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?

As a developer, you will be getting the following outcomes when you complete this course:

1. Utilize Move to build on Aptos
2. Build Token Contract on Aptos
3. Claim your NFT upon course completion

## Proof of completion

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

![](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%201%20Getting%20Started/Lesson%201%20What%20Are%20We%20Building%20Today/Frame_3560411.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!

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


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/1.%20Getting%20Started/1.%20What%20Are%20We%20Building%20Today.md

What Are We Building Today

# Aptos Fungible Asset Standard

Hey there, everyone! We're thrilled to see your enthusiasm for learning with us! Let's dive right in and explore the Aptos Fungible Asset Standard that we'll use to build our contract. Get ready for an exciting journey of discovery!

## Fungible Tokens (FTs) and Non-Fungible Tokens (NFTs)

Let’s learn the most famous tokens in web3 space:

- **Fungible Tokens (FTs):** In blockchain lingo, fungible tokens are like digital coins where every coin is identical and interchangeable. Think of them like dollar bills or arcade tokens—same value, same properties!
- **Non-Fungible Tokens (NFTs):** NFTs are unique digital treasures stored on a blockchain. Unlike fungible tokens, each NFT is one-of-a-kind and can't be duplicated. They're perfect for representing collectibles, artworks, or even real-world items.

![Fungible Tokens (FTs) and Non-Fungible Tokens (NFTs).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%201%20Getting%20Started/Lesson%202%20Aptos%20Fungible%20Asset%20Standard/Fungible_Tokens_(FTs)_and_Non-Fungible_Tokens_(NFTs).png?raw=true)

The Aptos blockchain supports the creation of both types of tokens using the following standards:

1. **Aptos Fungible Asset Standard** for regular tokens, tokenized real-world assets, and in-game assets
2. **Aptos Digital Asset Standard** for NFTs: It is an advanced Non-Fungible Token (NFT) standard for Aptos. NFTs, which represent unique on-chain assets, are organized into collections. These NFTs can be modified, transferred, soulbound, burned, or mutated through custom smart contracts.

These standards use Move's object model, making it a breeze for developers to work with and speeding up app development. By treating assets as objects, developers can easily add custom properties and save them as resources.

## Aptos Fungible Asset Standard

The Aptos Fungible Token standard defines a set of rules and guidelines for creating fungible tokens on the Aptos blockchain. It essentially acts as a blueprint for developers to ensure their tokens adhere to specific functionalities and interoperability within the Aptos ecosystem.

### Key Aspects

The key aspects of these asset standards are:

- **Resource-Based Design:** Tokens are represented by resources stored on the blockchain, ensuring uniqueness and preventing accidental deletion.
- **Supply Management:** Functions for minting (creating new tokens) and burning (destroying tokens) give developers control over the token supply.
- **Transferable:** A `transfer` function makes sending and receiving tokens within the Aptos network easy.
- **Metadata Support:** Optional metadata can store extra information about the token, like its name and description.
- **Security:** The standard leverages Move's safety features, including access control and resource ownership validation, ensuring secure transactions.
- **Interoperability:** Promotes seamless integration of tokens across different contracts and DeFi applications built on Aptos.
- **Frozen state:** The creator of fungible assets can freeze the interchange of fungible assets. 

![Aptos Fungible Asset Standard (1)](https://github.com/user-attachments/assets/abebf2fa-a121-4007-b881-441d70405d46)


## Deep Dive Into FA Standard

All the resources defined in the Aptos FA standard are included in the object resource group and stored inside objects. There are two types of objects related to FA:

- **Object\<Metadata\>**: Include information about the FA, such as name, symbol, and decimals.
- **Object\<FungibleStore\>**: Store a specific amount of FA units. FAs are units that are interchangeable with others of the same metadata.

Don’t worry! We will get into these terms and it will be so easy for you to understand and implement them. 

## Metadata Object

The `Metadata` struct defines the properties that describe a fungible asset type:

```
struct Metadata has key {
    supply: Option<Supply>,
    name: String,
    symbol: String,
    decimals: u8,
}
```

- `supply` (optional): Total number of tokens in existence (if applicable).
- `name`: Human-readable name of the asset (e.g., "META Coin").
- `symbol`: Shorter abbreviation for the asset (e.g., "META").
- `decimals`: Number of decimal places for display purposes (e.g., 2 for cents).

## Fungible Asset

The Aptos fungible asset standard introduces a concept called Fungible Assets (FAs). These FAs act like temporary containers holding information about a specific type and amount of fungible tokens.

## Fungible Store

Since FAs are temporary, Aptos relies on another concept called Fungible Stores for long-term storage and management of fungible tokens. The Fungible store is responsible for storing a specific amount of FA. These stores act like bank accounts for your tokens, keeping track of the total balance and frozen state for a specific asset type.

### More into the FungibleStore

Each `FungibleStore` object has an owner. However, an owner may possess more than one store. Let’s say Alice wants to send some FA to Bob, how does she determine the correct destination? Additionally, what happens if Bob doesn't have a store yet?

To address these questions, the standard has been expanded to define primary and secondary stores.

1. **Primary Fungible Store:** It is responsible for the main storage responsible for core functionalities of the fungible asset. It references Metadata for asset details and is linked to Alice as the owner, enabling her to perform operations like transferring tokens, minting, or burning.
    - Each account owns **only one non-deletable** primary store per FA type.
    - The address is derived deterministically from the account address and metadata object address using the sha256 hash function.
    - If a primary store does not exist, it is created automatically when FA is deposited.
2. **Secondary Fungible Store:** It manages additional functionalities beyond basic asset management. It references Metadata for consistency in asset details and is linked to Alice as the owner, allowing her to use extended functionalities for complex scenarios like DeFi etc.

The Owner, Alice owns and controls both the Primary and Secondary Fungible Stores, conducting operations like sending and receiving tokens and managing secondary stores for advanced use cases. 

The different objects involved - Object<Metadata> and Object<FungibleStore> objects, and their relationships to accounts are shown in the diagram below:

![Fungible store.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%201%20Getting%20Started/Lesson%202%20Aptos%20Fungible%20Asset%20Standard/Fungible_store.jpg?raw=true)

### References

The Aptos Fungible Asset standard introduces a powerful concept called "References" (refs) for implementing granular permission control. Think of refs as special tokens that grant specific abilities. These abilities can be used to mint new tokens, transfer existing ones, or even burn them (destroy).

**Types of References:**

The FA standard defines three distinct types of refs:

- **MintRef:** Grants the ability to mint new tokens of a specific asset type (metadata).
- **TransferRef:** Allows for transferring existing tokens, even if the asset type is frozen (deposits/withdrawals disabled).
- **BurnRef:** Grants the power to burn (destroy) existing tokens.

![Types of References.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%201%20Getting%20Started/Lesson%202%20Aptos%20Fungible%20Asset%20Standard/Types_of_References.jpg?raw=true)

**How it Works:**

- Each ref holds a reference to the metadata object, which identifies the specific fungible asset type it applies to.
- Owning a particular ref allows you to perform specific actions:
    - **MintRef:** You can mint new tokens of the associated asset type.
    - **TransferRef:** You can transfer existing tokens of the asset type, bypassing any freeze restrictions.
    - **BurnRef:** You can burn (destroy) existing tokens of the asset type.

## That’s a Wrap

Bravo for learning so diligently! We’ve covered the Aptos Fungible Standard, making it simple for developers to create various useful FTs on Aptos, from loyalty points to in-game currencies and digital assets like concert tickets. It’s like a pre-built box template with clear instructions. Stay tuned for more exciting lessons ahead!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/1.%20Getting%20Started/2.%20Aptos%20Fungible%20Asset%20Standard.md

Aptos Fungible Asset Standard

# Set Up the Environment Wizard

Hey there, welcome back! You've been crushing it so far, understanding the Aptos Fungible Asset Standard. Now, it's time to take the next step and set up our development environment with all the necessary dependencies.

> **Well, if you have already installed the Petra wallet and Aptos CLI, skip to the next lesson after completing the assignment.**
> 

## Setup Petra Wallet

1. Download the [Petra Aptos Wallet Chrome extension](https://petra.app/).
2. Click the “Create New Wallet” button.
3. Create a password and securely store your recovery phrase, never share it with anyone. Write it somewhere because if you lose it, you will never have a way to recover your account. So be mindful of that.

( Pin the Petra Aptos Wallet extension to your taskbar, coz we’ll be needing it quite often )

![aptos-petra-1-02-create-new-wallet-35b6d39c458c5c1ff6882a496f257cfd.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/aptos-petra-1-02-create-new-wallet-35b6d39c458c5c1ff6882a496f257cfd.png?raw=true)

## Change the network

We will be deploying our code to the Testnet, so we need to change the network to which our wallet is connected. Follow the steps given below to change it:

1. Go to “Settings” which is at the bottom right corner.
2. Click on the “Network”.
3. Select “Testnet”.

And with this, we have successfully changed the network.

![Frame 3560393 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560393_(1).jpg?raw=true)

## Copy the essentials

There are two key essential pieces of information that you’ll require quite often for the purpose of development and deployment. 

1. Wallet Address 
2. Private Key 

Follow the steps given below to copy and save these:

1. Go to “Settings” which is at the bottom right corner.
2. Scroll down and go to “Manage account”.
3. Enter the password for your Petra wallet and click on Next.
4. Copy the wallet address and save it somewhere secure.
5. Click on “Show” under the Private key.
6. Copy the private key and save it somewhere secure.
- Make sure to NEVER SHARE the private key with anyone. This is very private info and if someone gets access to it, they can hack into your account easily. So stay careful and safe!

![Frame 3560394 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560394_(1).jpg?raw=true)

## Fund the wallet

Here we have another important step to do and that is to fund the wallet. We need money to deploy our code so let’s ask for some fake money. Aptos deals in APT coins.

Click on the “Faucet” button and you will get 1 APT. Well, we clicked it twice to get 2 APT 😇. 

![Frame 3560395 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560395_(1).jpg?raw=true)

## Installation on System

I’ll tell you step-by-step installation for your operating system (OS) which might be Mac, Linux, or Windows. So, opt for the OS you are using, and follow the steps. 

### Installation on Mac

![Frame 3560400 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560400_(2).jpg?raw=true)

1. First, you need a `brew` package. The `brew` allows you to install the packages on Apple easily. Open a terminal on your Mac and run the following command. It will ask for your laptop’s password, provide it, and continue with the installation.
    
    ```
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    ```
    
2. Open a new terminal and run the following commands:
    
    ```
        brew update
        brew install aptos
    ```
    
3. Now restart the terminal or open another terminal and run the following command to verify if the CLI is installed.
    
    ```
       aptos help
    ```
    

How easy was it~ 

> **Well, if you are a Mac user, the installation part is done, move to the next lesson.**
> 

### Installation on Linux

![Frame 3560401 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560401_(1).jpg?raw=true)

Before starting, just a little heads up: The set of instructions that we’ll discuss are of Ubuntu-based systems and anyone using a different Linux distribution can use their native package managers to install the same dependencies.

Open the terminal and run the following command to install the package. It will ask for your laptop’s password so provide it.

```
sudo install apt-get
```

Aptos peeps suggest that the best and easiest way to install the Aptos CLI tool is through Python script. So let’s install it by running the following command:

```
sudo apt-get install python
```

It will install the latest version of the python. You need a 3.6+ version. You can verify it using **`python --version`. 

Next, you have to ensure that you can use Python in every terminal so to do that you add the path where Python is installed to an environment variable called `PATH`. The variable `PATH` instructs Linux to the directories where it can search for the packages.

So let’s add Python to your `PATH`:

- Run `which python`, it tells where python has been installed on the system i.e., it gives you the path.
- Now run `export PATH=$PATH:/path/to/python` to add the python path to your variable.
- Now install `curl` and then install Aptos CLI using the following commands:
    
    ```
    sudo apt-get install curl
    curl -fsSL "https://aptos.dev/scripts/install_cli.py" | python3
    ```
    
- Or you can use `wget` which is a tool to download the files from the internet from the terminal directly. You can install Aptos CLI using the following commands:
    
    ```
    sudo apt-get install wget
    wget -qO- "https://aptos.dev/scripts/install_cli.py" | python3
    ```
    
- Now restart the terminal or open another terminal and run the following command to verify if the CLI is installed.
    
    ```
       aptos help
    ```
    

> **Awesome! You are good to go to the next lesson!**
> 

### Installation on Windows

![Frame 3560399 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560399_(1).jpg?raw=true)

You can install the Aptos CLI using the python. So first install Python by following the steps given:

1. Visit the [Python website and download the package](https://www.python.org/downloads/windows/) according to your system architecture.
2. Check your Downloads folder to see the package. 
3. Install the package and you’re set up for python.

Now follow the steps given below to install the CLI:

1. Open PowerShell using the Start Menu.
2. Run the following command:
    
    ```
    iwr "https://aptos.dev/scripts/install_cli.py" -useb | Select-Object -ExpandProperty Content | python3
    ```
    
3. The command’s output will show you a command to set the `PATH` variable, make sure to run it.
4. Run the following command to verify if the CLI is installed.
    
    ```
       aptos help
    ```
    

## That’s a wrap

Whew! We’ve conquered the installation phase, and now it’s time to dive into the fun stuff! Get ready because in the next lesson, we’re rolling up our sleeves to create a project for our fungible token. Let’s bring those coding dreams to life! 

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/2.%20Set%20Up%20Dev%20Environment/3.%20Set%20Up%20the%20Environment%20Wizard.md

# Set Up the Token Project on Move

Alright Guys! let's get things rolling by setting up our Token project . We'll dive right in using the same tried and tested steps from our previous course. By the end of this setup, we'll be ready to hit the ground running and start implementing our Token. 

## Aptos CLI

Aptos CLI is pretty much like a Swiss-army knife when it comes to being able to develop and interact with the Aptos blockchain. But before we get into why the Aptos CLI is so important, let’s set some context on why we need a CLI in the first place.

### Why Do We Need a CLI?

When you're developing on the Aptos blockchain, you've got tasks like creating accounts, working with smart contracts, managing keys, and setting up nodes. Doing all this by clicking around in a graphical interface takes forever and can lead to mistakes. A CLI or Command line interface makes it easy, you just type commands to get things done fast. It’s all about getting things done efficiently. 

### The Importance of Aptos CLI

The Aptos CLI is your go-to tool for developing and interacting with the Aptos blockchain. It’s designed to simplify a wide range of tasks, making your development process smoother and more efficient. If you want a glimpse of all operations Aptos CLI can do for you, then run the command in your terminal to see all the commands available at your disposal.

```
aptos --help
```

![aptos 02.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%204%20Set%20Up%20the%20Token%20Project%20on%20Move/aptos_02.jpg?raw=true)

The CLI provides a variety of commands that cover all aspects of interacting with the Aptos blockchain. Here are some of the key commands you’ll be using:

- **account:** Tool for interacting with accounts. This includes creating new accounts, checking balances, and managing account-related activities.
- **config:** Tool for managing the configuration of the Aptos CLI tool. It helps you set up and modify settings to suit your development environment.
- **genesis:** Tool for setting up an Aptos chain Genesis transaction. This is essential for initializing the blockchain network.
- **governance:** Tool for on-chain governance. It allows you to participate in governance activities, like voting on proposals.
- **info:** Shows build information about the CLI. Useful for checking the version and other details about your CLI installation.
- **init:** Tool to initialize the current directory for the Aptos tool. Sets up the necessary files and structure for your project.
- **key:** Tool for generating, inspecting, and interacting with keys. Essential for security and identity management.
- **move:** Tool for Move related operations. Move is the smart contract language used by Aptos, and this command helps you compile, publish, and interact with Move modules.
- **multisig:** Tool for interacting with multisig accounts. Multisig accounts require multiple signatures for transactions, adding an extra layer of security.
- **node:** Tool for operations related to nodes. This includes starting, stopping, and managing blockchain nodes.
- **stake:** Tool for manipulating stake and stake pools. Useful for participating in the network’s proof-of-stake consensus mechanism.

Using these commands, you can efficiently manage and develop on the Aptos blockchain. The CLI is a powerful ally in your development toolkit, providing the flexibility and control you need to build and maintain your blockchain applications.

## Your Move project

Before setting up, we have some pre-requisites to do. Let’s complete those:

1. **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.
2. **Git CLI:** It allows to connect with git via 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 favorite 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, 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 by entering your GitHub password.
        6. Do not close this terminal!

![gh login.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%204%20Set%20Up%20the%20Token%20Project%20on%20Move/gh_login.gif?raw=true)

Awesome, you are all set!! Good job!

### Initialize the project

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

```
gh repo fork https://github.com/0xmetaschool/create-fungible-token-on-aptos.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 this command:

```
cd create-fungible-token-on-aptos
```

The next thing we need to do is set up our Aptos CLI to work with our account. We'll use the `aptos init` command inside our directory.

1. You’ll be prompted to choose a network when you run the above command. Type `testnet` and press Enter.
2. Next, provide your private key we copied in the last lesson when prompted and hit enter.

And there you have it! The Aptos CLI is successfully set up. 

![aptos 03.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%204%20Set%20Up%20the%20Token%20Project%20on%20Move/aptos_03.jpg?raw=true)

## That’s a wrap

We've successfully set up our Move project to start implementing our Token Contract. In the upcoming lesson, we'll be adding essential components to our Move file to prepare our Token for minting!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/2.%20Set%20Up%20Dev%20Environment/4.%20Set%20Up%20the%20Token%20Project%20on%20Move.md

Set Up the Token Project on Move

# Build the Foundations

Welcome back! You have been doing great and we are proud of you! In the previous lesson, we have set up our project.

In this lesson, we will be diving into the core components that establish the groundwork for our fungible token contract on Aptos. We'll explore the imports, define a struct, and unpack the `init_module` function responsible for initializing the token. We will then examine the `get_metadata` function and wrap up this section.

![block.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%205%20Build%20the%20Foundations/block.gif?raw=true)

## Imports and Constants

Before we dive into imports and constants, let's discuss modules. In Move, a module functions similarly to a "class" in other programming languages. It packages everything a Move smart contract requires, including imports, variables, and functions. Here in our case `aptos_asset::fungible_asset` module provides the necessary functionalities to create fungible tokens within the Aptos ecosystem. We import functionalities like `MintRef`, `TransferRef`, and `BurnRef` to manage the minting, transferring, and burning of our token units, respectively. Additionally, imports from `aptos_framework` grant access to core functionalities like object management and fungible asset utilities.

The module also defines constants such as `ENOT_OWNER`, which represents an error code for non-owner access attempts, and `ASSET_SYMBOL`, which specifies the symbol for the fungible asset.

Okay enough talking let's get our hands dirty with some code. Navigate to the `create-fungible-token-on-aptos/sources/fungible_asset.move` and add the following code:

```
module aptos_asset::fungible_asset {
    // Importing the necessary modules
    use aptos_framework::fungible_asset::{Self, MintRef, TransferRef, BurnRef, Metadata, FungibleAsset};
    // Importing functionalities for fungible assets, including self-reference, minting, transferring, burning, metadata, and fungible asset utilities.

    use aptos_framework::object::{Self, Object};
    // Importing object management functionalities, including self-reference and object handling.

    use aptos_framework::primary_fungible_store;
    // Importing the primary fungible store module.

    use std::error;
    // Importing standard error handling functionalities.

    use std::signer;
    // Importing functionalities for handling signers.

    use std::string::utf8;
    // Importing functionalities for UTF-8 string manipulation.

    use std::option;
    // Importing functionalities for handling optional values.

    /// Only fungible asset metadata owner can make changes.
    // Constants
    const ENOT_OWNER: u64 = 1;
    // Error code indicating that the action is not allowed because the user is not the owner of the fungible asset metadata.

    const ASSET_SYMBOL: vector<u8> = b"META";
    // Symbol for the fungible asset, represented as a vector of bytes.

    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
    /// Hold refs to control the minting, transfer and burning of fungible assets.
    struct ManagedFungibleAsset has key {
        mint_ref: MintRef, // Reference for minting assets
        transfer_ref: TransferRef, // Reference for transferring assets
        burn_ref: BurnRef, // Reference for burning assets
    }
}

```

Now we know all these can be a bit overwhelming for you, so let us walk you through the code and explain each block!

## ManagedFungibleAsset

The `ManagedFungibleAsset` struct serves as a crucial element in our contract. It acts as a container, holding references to three essential functionalities:

- `mint_ref`: This reference grants permission for minting new tokens.
- `transfer_ref`: This reference authorizes transfers of existing tokens between accounts.
- `burn_ref`: This reference allows burning (destroying) existing tokens.

By encapsulating these references within a struct, we maintain a clear separation of concerns and ensure proper access control for each operation.

```
struct ManagedFungibleAsset has key {
        mint_ref: MintRef,
        transfer_ref: TransferRef,
        burn_ref: BurnRef,
    }
```

## init_module function

The `init_module` function plays a pivotal role in initializing the token contract. Here's a breakdown of its key actions:

1. **Object Creation:**
    - It establishes a named object using `object::create_named_object` and assigns it the symbol defined in `ASSET_SYMBOL`. This object serves as the central storage for our token's metadata.
2. **Metadata Initialization:**
    - The function leverages `primary_fungible_store::create_primary_store_enabled_fungible_asset` to configure the primary store for our fungible asset. This store maintains the token balances for each account.
    - It then defines various metadata details like name, symbol, decimals, icon URL, and project URL.
3. **Reference Generation:**
    - The function generates separate references (`mint_ref`, `burn_ref`, and `transfer_ref`) for minting, burning, and transferring tokens, respectively.
    - It retrieves the signer associated with the newly created object using `object::generate_signer`.
4. **Resource Initialization:**
    - Finally, it assigns the generated references to the `ManagedFungibleAsset` struct and stores it within the metadata object using `move_to`. This establishes the initial state of our managed fungible asset resource.
    

Here is how the code looks like:

```
fun init_module(admin: &signer) {
    // Create a named object for the asset using the admin signer and the asset symbol
    let constructor_ref = &object::create_named_object(admin, ASSET_SYMBOL);

    // Create the primary store for the fungible asset with the specified metadata
    primary_fungible_store::create_primary_store_enabled_fungible_asset(
        constructor_ref,
        option::none(), // No specific options
        utf8(b"META Coin"), // Name of the asset
        utf8(ASSET_SYMBOL), // Symbol of the asset
        8, // Number of decimals
        utf8(b"https://drive.google.com/file/d/1vFm-kF6O3onxPgFJ_rVLh9YGFT_fFWM6/view?usp=sharing"), // Icon URL
        utf8(b"http://metaschool.so"), // Project URL
    );

    // Create mint, burn, and transfer references to allow the creator to manage the fungible asset
    let mint_ref = fungible_asset::generate_mint_ref(constructor_ref);
    let burn_ref = fungible_asset::generate_burn_ref(constructor_ref);
    let transfer_ref = fungible_asset::generate_transfer_ref(constructor_ref);

    // Generate a signer for the metadata object
    let metadata_object_signer = object::generate_signer(constructor_ref);

    // Move the managed fungible asset to the metadata object signer's account
    move_to(
        &metadata_object_signer,
        ManagedFungibleAsset { mint_ref, transfer_ref, burn_ref }
    ); // Initialize the managed fungible asset
}

```

## get_metadata function

The `get_metadata` function serves a simple yet vital purpose. It retrieves the address of the object that holds our token's metadata. This address can be used for various purposes, such as interacting with the contract's functions that require access to the metadata.

```
public fun get_metadata(): Object<Metadata> {
        let asset_address = object::create_object_address(&@aptos_asset, ASSET_SYMBOL);
        object::address_to_object<Metadata>(asset_address)
    }
```

## Complete Code

Here’s what the final code we wrote till now looks like:

```

module aptos_asset::fungible_asset{
    use aptos_framework::fungible_asset::{Self, MintRef, TransferRef, BurnRef, Metadata, FungibleAsset};
    use aptos_framework::object::{Self, Object};
    use aptos_framework::primary_fungible_store;
    use std::error;
    use std::signer;
    use std::string::utf8;
    use std::option;

    /// Only fungible asset metadata owner can make changes.
    const ENOT_OWNER: u64 = 1;

    const ASSET_SYMBOL: vector<u8> = b"META";

    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
    /// Hold refs to control the minting, transfer and burning of fungible assets.
    struct ManagedFungibleAsset has key {
        mint_ref: MintRef,
        transfer_ref: TransferRef,
        burn_ref: BurnRef,
    }

    /// Initialize metadata object and store the refs.
    // :!:>initialize
    fun init_module(admin: &signer) {
        let constructor_ref = &object::create_named_object(admin, ASSET_SYMBOL);
        primary_fungible_store::create_primary_store_enabled_fungible_asset(
            constructor_ref,
            option::none(),
            utf8(b"META Coin"), /* name */
            utf8(ASSET_SYMBOL), /* symbol */
            8, /* decimals */
            utf8(b"https://drive.google.com/file/d/1vFm-kF6O3onxPgFJ_rVLh9YGFT_fFWM6/view?usp=sharing"), /* icon */
            utf8(b"http://metaschool.so"), /* project */
        );

        // Create mint/burn/transfer refs to allow creator to manage the fungible asset.
        let mint_ref = fungible_asset::generate_mint_ref(constructor_ref);
        let burn_ref = fungible_asset::generate_burn_ref(constructor_ref);
        let transfer_ref = fungible_asset::generate_transfer_ref(constructor_ref);
        let metadata_object_signer = object::generate_signer(constructor_ref);
        move_to(
            &metadata_object_signer,
            ManagedFungibleAsset { mint_ref, transfer_ref, burn_ref }
        )// <:!:initialize
    }

    #[view]
    /// Return the address of the managed fungible asset that's created when this module is deployed.
    public fun get_metadata(): Object<Metadata> {
        let asset_address = object::create_object_address(&@aptos_asset, ASSET_SYMBOL);
        object::address_to_object<Metadata>(asset_address)
    }    
}
```

Make sure your `create-fungible-token-on-aptos/sources/fungible_asset.move` file is updated with the latest code and then in your opened terminal, run the following commands:

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

## That’s a wrap

In essence, using a struct resource in this context offers a structured approach for managing the essential references required for operating our fungible token contract. This concludes our lesson. Congratulations!! By understanding these core concepts, you've laid a solid foundation for building a functional token contract on Aptos.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/3.%20Build%20Your%20Token/5.%20Build%20the%20Foundations.md

Build the Foundations

# Set Up the Fundamentals

In this lesson, we will walk through the process of building three fundamental functions—mint, transfer, and burn—that are essential for any token contract. These functions will be implemented in a smart contract to manage a fungible asset. 

## Mint Function

![1 (2).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%206%20Set%20Up%20the%20Fundamentals/1_(2).gif?raw=true)

The mint function creates new tokens and transfers them to a specified address. It is typically used to mint new tokens into the circulating supply.

```
 public entry fun mint(admin: &signer, to: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let managed_fungible_asset = authorized_borrow_refs(admin, asset);
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        let fa = fungible_asset::mint(&managed_fungible_asset.mint_ref, amount);
        fungible_asset::deposit_with_ref(&managed_fungible_asset.transfer_ref, to_wallet, fa);
    }
```

### Code Explanation

Now, let’s try to understand this function:

```
public entry fun mint(admin: &signer, to: address, amount: u64) acquires ManagedFungibleAsset
```

- Public entry makes sure that this function is public and can be called externally. It requires a signer (`admin`), a recipient address (`to`), and an amount to be minted (`amount`). It also acquires the `ManagedFungibleAsset` resource which basically stores the ability to mint, transfer and burn if you remember from our last lesson.

```jsx
let asset = get_metadata();
```

- First, let's fetch the metadata object associated with the fungible asset

```jsx
let managed_fungible_asset = authorized_borrow_refs(admin, asset);
```

- Ensure the caller is authorized to perform the mint operation.

```jsx
let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
```

- Now let's ensure that the recipient's wallet exists. If not, it creates one.

```jsx
let fa = fungible_asset::mint(&managed_fungible_asset.mint_ref, amount);
```

- Now let's mint the specified amount of tokens.

```jsx
fungible_asset::deposit_with_ref(&managed_fungible_asset.transfer_ref, to_wallet, fa);
```

- And finally, deposit the newly minted tokens into the recipient's wallet.

## Transfer Function

![2 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%206%20Set%20Up%20the%20Fundamentals/2_(1).gif?raw=true)

The transfer function moves tokens from one address to another. It is used to facilitate transactions between users.

```jsx
public entry fun transfer(admin: &signer, from: address, to: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        fungible_asset::transfer_with_ref(transfer_ref, from_wallet, to_wallet, amount);
    }
```

### Code Explanation

Now, let’s try to understand this function:

```jsx
public entry fun transfer(admin: &signer, from: address, to: address, amount: u64) acquires ManagedFungibleAsset
```

- Again this function is public and can be called externally. It requires a signer (`admin`), the sender address (`from`), the recipient address (`to`), and the amount to transfer (`amount`). It also acquires the `ManagedFungibleAsset` resource.

```jsx
let asset = get_metadata();
```

- So we will start with fetching the metadata object associated with the fungible asset.

```jsx
let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
```

- This line of code ensures the caller is authorized to perform the transfer operation.

```jsx
let from_wallet = primary_fungible_store::primary_store(from, asset);
```

- Now let's retrieve the sender's wallet.

```jsx
let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
```

- Ensures the recipient's wallet exists. If not, this line creates one.

```jsx
fungible_asset::transfer_with_ref(transfer_ref, from_wallet, to_wallet, amount);
```

- Transfers the specified amount of tokens from the sender's wallet to the recipient's wallet.

## Burn Function

![3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%206%20Set%20Up%20the%20Fundamentals/3.gif?raw=true)

The burn function destroys a specified amount of tokens from a given address, reducing the circulating supply.

```jsx
 public entry fun burn(admin: &signer, from: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let burn_ref = &authorized_borrow_refs(admin, asset).burn_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        fungible_asset::burn_from(burn_ref, from_wallet, amount);
    }
```

### Code Explanation

Now, let’s try to understand this function:

```jsx
public entry fun burn(admin: &signer, from: address, amount: u64) acquires ManagedFungibleAsset
```

- The function is public and can be called externally. It requires a signer (`admin`), the address from which to burn tokens (`from`), and the amount to burn (`amount`). It also acquires the `ManagedFungibleAsset` resource.

```jsx
let asset = get_metadata();
```

- Fetches the metadata object associated with the fungible asset.

```jsx
let burn_ref = &authorized_borrow_refs(admin, asset).burn_ref;
```

- Ensures the caller is authorized to perform the burn operation.

```jsx
let from_wallet = primary_fungible_store::primary_store(from, asset);
```

- Retrieves the wallet of the address from which tokens are to be burned.

```jsx
fungible_asset::burn_from(burn_ref, from_wallet, amount);
```

- Burns the specified amount of tokens from the given address's wallet.

## Complete Code

Here is the complete code for the token contract, so add the following code under `module aptos_asset::fungible_asset` after the `get_metadata()` function: 

```
public entry fun mint(admin: &signer, to: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let managed_fungible_asset = authorized_borrow_refs(admin, asset);
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        let fa = fungible_asset::mint(&managed_fungible_asset.mint_ref, amount);
        fungible_asset::deposit_with_ref(&managed_fungible_asset.transfer_ref, to_wallet, fa);
    }// <:!:mint

    /// Transfer as the owner of metadata object ignoring `frozen` field.
    public entry fun transfer(admin: &signer, from: address, to: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        fungible_asset::transfer_with_ref(transfer_ref, from_wallet, to_wallet, amount);
    }

    /// Burn fungible assets as the owner of metadata object.
    public entry fun burn(admin: &signer, from: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let burn_ref = &authorized_borrow_refs(admin, asset).burn_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        fungible_asset::burn_from(burn_ref, from_wallet, amount);
    }
```

Make sure your `create-fungible-token-on-aptos/sources/fungible_asset.move` file is updated with the latest code and then in your opened terminal, run the following commands:

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

## That’s a Wrap

That’s all for this lesson. Congratulations!!! We have so much more to explore which we will do in the next one. By implementing these core functions, we empower users to interact with our token contract and manage the supply and distribution of our fungible tokens on the Aptos blockchain.

![Frame 3560414.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%206%20Set%20Up%20the%20Fundamentals/Frame_3560414.gif?raw=true)

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/3.%20Build%20Your%20Token/6.%20Set%20Up%20the%20Fundamentals.md

Set Up the Fundamentals

# Finalize the essentials

Welcome back gang! Let’s add in some more functionalities to our token contract. We want our token to be able to be withdrawn and deposited seamlessly. But hey, it’s not just about moving tokens around; we also want to give accounts the option to freeze or unfreeze, adding an extra layer of control to our system. So let’s get these functions implemented. 
![aptos04-ezgif com-resize](https://github.com/user-attachments/assets/72b7cf0d-8cbc-47fd-84eb-b7a0d2e4a4a3)


## Authorized Borrow References

Before we head out into implementing all of these functions, It’s super important to ensure that only authorized individuals can perform sensitive operations. So we’ll create a function called `authorized_borrow_refs` to verify ownership and provide access to the necessary references for managing assets.

```
inline fun authorized_borrow_refs(
    owner: &signer,
    asset: Object<Metadata>,
): &ManagedFungibleAsset acquires ManagedFungibleAsset {
    assert!(object::is_owner(asset, signer::address_of(owner)), error::permission_denied(ENOT_OWNER));
    borrow_global<ManagedFungibleAsset>(object::object_address(&asset))
}
```

The `authorized_borrow_refs` function will take two parameters:

- `owner`: The signer (Owner/Administrator) who is requesting access to the asset references.
- `asset`: The metadata object associated with the token, containing essential information about the token.

In-order to perform the verification, we will use the `is_owner` function to check if the `owner` we have provided via the parameters is actually the owner or not using the `assert` macro. If the assertion fails we will throw a `permission_denied(ENOT_OWNER)` error.

Finally If ownership checks out, the function then grabs a managed reference of `ManagedFungibleAsset` to the global resource using `object_address(&asset)`. We have used the same function in our previous function definitions as well.

## Withdraw

The `withdraw` function will be responsible to let the token owner withdraw tokens from a specified address. It returns a `FungibleAsset` representing the withdrawn tokens and acquires the `ManagedFungibleAsset` resource.

```
public fun withdraw(admin: &signer, amount: u64, from: address): FungibleAsset acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let from_wallet = primary_fungible_store::primary_store(from, asset);
    fungible_asset::withdraw_with_ref(transfer_ref, from_wallet, amount)
}
```

The withdraw function will take three parameters :

- `admin`: The signer who is authorizing the withdrawal. This should be the owner of the metadata object.
- `amount`: The amount of tokens to withdraw.
- `from`: The address from which the tokens will be withdrawn.

We will be using the `withdraw_with_ref()` from the `fungible_asset` module we imported to perform the withdraw operation. This function requires a few parameters for it to function so let’s get them sorted.

- `get_metadata()` retrieves the metadata object associated with the token.
- `authorized_borrow_refs(admin, asset)` function we had created earlier verifies that the admin owns the metadata object and provides the  `transfer_ref to` authorize and execute token transfers.
- `primary_fungible_store::primary_store(from, asset)` retrieves the primary store (wallet) of the address `from` for the given `asset`. This store holds the tokens of the `from` address.

Finally we can use the above data with the `fungible_asset::withdraw_with_ref` function to withdraw the specified amount of tokens from `from_wallet` using `transfer_ref` to ensure authorization.

## Deposit

The `deposit` function allows the owner of the token to deposit a specified amount of tokens into a given address. 

```
public fun deposit(admin: &signer, to: address, fa: FungibleAsset) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
    fungible_asset::deposit_with_ref(transfer_ref, to_wallet, fa);
}
```

The `deposit` function will also take these parameters:

- `admin`: The signer authorizing the deposit. This should be the owner of the token.
- `to`: The address where the tokens will be deposited.
- `fa`: The `FungibleAsset` representing token to deposit.

We will be using the `deposit_with_ref()` from the `fungible_asset` module in order to perform the deposit operation. This function too requires a few parameters for it to function :

- `get_metadata()` retrieves the metadata object associated with the token and stores them as the `asset` variable.
- `authorized_borrow_refs(admin, asset)` function from earlier for verification.
- `primary_fungible_store::ensure_primary_store_exists(to, asset)`: Ensures that a primary store (wallet) exists for the address `to` for the given `asset`. If it does not exist, it creates one.

Finally, we can use the above data with the `deposit_with_ref()` function to deposit the specified amount of tokens into `to_wallet` using `transfer_ref` to ensure authorization.

## Freezing an Account

Let’s assume we've got a token contract running smoothly, but suddenly, we spot some suspicious activity on one of the accounts. Maybe there's been a security breach, or the account owner is up to no good. That's when freezing an account becomes absolutely necessary to prevent damage. 

![4.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%207%20Finalize%20the%20essentials/4.gif?raw=true)

```
public entry fun freeze_account(admin: &signer, account: address) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let wallet = primary_fungible_store::ensure_primary_store_exists(account, asset);
    fungible_asset::set_frozen_flag(transfer_ref, wallet, true);
}
```

The `freeze_account` function accepts the following parameters:

- `admin`: The signer who is authorized to freeze the account. Typically, this would be the contract owner or an administrator.
- `account`: The address of the account whose assets are to be frozen.

We will be using the `set_frozen_flag` in order to freeze an account, this is how the function will work: 

1. Retrieve the asset metadata using `get_metadata()` .
2. Verify the admin's ownership using `authorized_borrow_refs` to get the transfer reference.
3. Ensure the account's primary store (wallet) exists with `ensure_primary_store_exists`
4. Finally set the asset's frozen flag to true using `set_frozen_flag` .

TL;DR The `freeze_account` function allows administrators to prevent unauthorized asset transfers from specific accounts.

## Unfreezing an Account

Now let’s suppose our account was previously frozen due to a security concern or suspicious activity. Now, after a thorough investigation and resolution of the issues, it's time to restore the account's functionality. The `unfreeze_account` function is designed for this purpose, allowing authorized administrators to unfreeze an account and resume normal operations.

![5.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%203%20Build%20Your%20Token/Lesson%207%20Finalize%20the%20essentials/5.gif?raw=true)

```
public entry fun unfreeze_account(admin: &signer, account: address) acquires ManagedFungibleAsset {
    let asset = get_metadata();
    let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
    let wallet = primary_fungible_store::ensure_primary_store_exists(account, asset);
    fungible_asset::set_frozen_flag(transfer_ref, wallet, false);
}
```

The `unfreeze_account` function is almost the same as the `freeze_account` function, the only difference being that we will set the frozen flag to `false` and the entire implementation is the same as that of `freeze_acount`. 

## Complete Code

Here is the complete code for the `fungible_asset.move` :

```

module aptos_asset::fungible_asset{
    use aptos_framework::fungible_asset::{Self, MintRef, TransferRef, BurnRef, Metadata, FungibleAsset};
    use aptos_framework::object::{Self, Object};
    use aptos_framework::primary_fungible_store;
    use std::error;
    use std::signer;
    use std::string::utf8;
    use std::option;

    /// Only fungible asset metadata owner can make changes.
    const ENOT_OWNER: u64 = 1;

    const ASSET_SYMBOL: vector<u8> = b"META";

    #[resource_group_member(group = aptos_framework::object::ObjectGroup)]
    /// Hold refs to control the minting, transfer and burning of fungible assets.
    struct ManagedFungibleAsset has key {
        mint_ref: MintRef,
        transfer_ref: TransferRef,
        burn_ref: BurnRef,
    }

    /// Initialize metadata object and store the refs.
    // :!:>initialize
    fun init_module(admin: &signer) {
        let constructor_ref = &object::create_named_object(admin, ASSET_SYMBOL);
        primary_fungible_store::create_primary_store_enabled_fungible_asset(
            constructor_ref,
            option::none(),
            utf8(b"META Coin"), /* name */
            utf8(ASSET_SYMBOL), /* symbol */
            8, /* decimals */
            utf8(b"https://drive.google.com/file/d/1vFm-kF6O3onxPgFJ_rVLh9YGFT_fFWM6/view?usp=sharing"), /* icon */
            utf8(b"http://metaschool.so"), /* project */
        );

        // Create mint/burn/transfer refs to allow creator to manage the fungible asset.
        let mint_ref = fungible_asset::generate_mint_ref(constructor_ref);
        let burn_ref = fungible_asset::generate_burn_ref(constructor_ref);
        let transfer_ref = fungible_asset::generate_transfer_ref(constructor_ref);
        let metadata_object_signer = object::generate_signer(constructor_ref);
        move_to(
            &metadata_object_signer,
            ManagedFungibleAsset { mint_ref, transfer_ref, burn_ref }
        )// <:!:initialize
    }

    #[view]
    /// Return the address of the managed fungible asset that's created when this module is deployed.
    public fun get_metadata(): Object<Metadata> {
        let asset_address = object::create_object_address(&@aptos_asset, ASSET_SYMBOL);
        object::address_to_object<Metadata>(asset_address)
    }

    // :!:>mint
    /// Mint as the owner of metadata object.
    public entry fun mint(admin: &signer, to: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let managed_fungible_asset = authorized_borrow_refs(admin, asset);
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        let fa = fungible_asset::mint(&managed_fungible_asset.mint_ref, amount);
        fungible_asset::deposit_with_ref(&managed_fungible_asset.transfer_ref, to_wallet, fa);
    }// <:!:mint

    /// Transfer as the owner of metadata object ignoring `frozen` field.
    public entry fun transfer(admin: &signer, from: address, to: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        fungible_asset::transfer_with_ref(transfer_ref, from_wallet, to_wallet, amount);
    }

    /// Burn fungible assets as the owner of metadata object.
    public entry fun burn(admin: &signer, from: address, amount: u64) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let burn_ref = &authorized_borrow_refs(admin, asset).burn_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        fungible_asset::burn_from(burn_ref, from_wallet, amount);
    }

    /// Freeze an account so it cannot transfer or receive fungible assets.
    public entry fun freeze_account(admin: &signer, account: address) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let wallet = primary_fungible_store::ensure_primary_store_exists(account, asset);
        fungible_asset::set_frozen_flag(transfer_ref, wallet, true);
    }

    /// Unfreeze an account so it can transfer or receive fungible assets.
    public entry fun unfreeze_account(admin: &signer, account: address) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let wallet = primary_fungible_store::ensure_primary_store_exists(account, asset);
        fungible_asset::set_frozen_flag(transfer_ref, wallet, false);
    }

    /// Withdraw as the owner of metadata object ignoring `frozen` field.
    public fun withdraw(admin: &signer, amount: u64, from: address): FungibleAsset acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let from_wallet = primary_fungible_store::primary_store(from, asset);
        fungible_asset::withdraw_with_ref(transfer_ref, from_wallet, amount)
    }

    /// Deposit as the owner of metadata object ignoring `frozen` field.
    public fun deposit(admin: &signer, to: address, fa: FungibleAsset) acquires ManagedFungibleAsset {
        let asset = get_metadata();
        let transfer_ref = &authorized_borrow_refs(admin, asset).transfer_ref;
        let to_wallet = primary_fungible_store::ensure_primary_store_exists(to, asset);
        fungible_asset::deposit_with_ref(transfer_ref, to_wallet, fa);
    }

    /// Borrow the immutable reference of the refs of `metadata`.
    /// This validates that the signer is the metadata object's owner.
    inline fun authorized_borrow_refs(
        owner: &signer,
        asset: Object<Metadata>,
    ): &ManagedFungibleAsset acquires ManagedFungibleAsset {
        assert!(object::is_owner(asset, signer::address_of(owner)), error::permission_denied(ENOT_OWNER));
        borrow_global<ManagedFungibleAsset>(object::object_address(&asset))
    }

}
```

Make sure your `create-fungible-token-on-aptos/sources/fungible_asset.move` file is updated with the latest code and then in your opened terminal, run the following commands:

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

And this sets up us for finally going in and deploy our contract to the Aptos Network.

![aptos05-ezgif com-resize](https://github.com/user-attachments/assets/20b214cf-df5b-4460-93d2-b12501cf9dbc)


## That’s a Wrap

We've added some powerful functionalities to our token contract, including the ability to withdraw, deposit, and freeze/unfreeze accounts. These features give us enhanced control and flexibility in managing our tokens. Now, let's move on to deploying our token to the Testnet!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/3.%20Build%20Your%20Token/7.%20Finalize%20the%20essentials.md

Finalize the essentials

# Deploy Your First Fungible Token on Aptos

Time to reap the rewards of all our hard work and finally deploy our contract! 🎉 With everything set up, it's time to bring our token to life on the blockchain. Let's dive in and make it happen!

## Deploying the contract

To deploy our token, we first need to set up the `Move.toml` file. So, head over to the `Move.toml` file in the root directory and replace the contents with the configurations given down below. Make sure to replace `<Replace-with-your-wallet-address>` with your wallet address.

```
[package]
name = 'MyToken'
version = '1.0.0'

[dependencies]
AptosFramework = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-framework", rev = "testnet" }
AptosStdlib = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-stdlib", rev = "testnet" }
AptosToken = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-token", rev = "testnet" }
AptosTokenObjects = { git = "https://github.com/aptos-labs/aptos-core.git", subdir = "aptos-move/framework/aptos-token-objects", rev = "testnet" }

[addresses]
aptos_asset = "<Replace-with-your-wallet-address>"
std = "0x1"
aptos_std = "0x1"
aptos_framework = "0x1"
aptos_token = "0x3"
aptos_token_objects = "0x4"
```

Next, compile the contract using the following command:

```
aptos move compile
```

Finally, deploy our token contract using the following command:

```
aptos move publish
```

![gif (3).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%204%20Deploy%20Your%20Token/Lesson%208%20Deploy%20Your%20First%20Fungible%20Token%20on%20Aptos/gif_(3).gif?raw=true)

Type “yes” when the command asks if you want to pay for the transaction. And Viola! you have successfully deployed your token contract onto the Testnet 💪.

## Interacting with the contract

Follow these steps to Mint some ‘Meta’ coins using your token contract using Aptos Explorer:

- Navigate to [Aptos Explorer](https://explorer.aptoslabs.com/?network=testnet) and connect your wallet to the explorer.
    
    ![aptos06-ezgif.com-crop.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%204%20Deploy%20Your%20Token/Lesson%208%20Deploy%20Your%20First%20Fungible%20Token%20on%20Aptos/gif_(3).gif?raw=true)
    
- Enter your wallet address in the search bar to view the details of your wallet.
- Under the Modules section, select the Run panel. This will show all the functions we can get executed.
- Select the `mint`function from the side panel, now enter your own address under `arg0` and specify the number of tokens you want to mint under `arg1`. Click run and authorize the transaction when prompted.
    
    ![aptos07.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%204%20Deploy%20Your%20Token/Lesson%208%20Deploy%20Your%20First%20Fungible%20Token%20on%20Aptos/aptos07.gif?raw=true)
    

You will now be able to view your newly minted coin under the Coin Section 🪙.  Let’s transfer some of our “Meta Coins” to another wallet address.

- Select the `transfer` function under the Run panel.
- Specify your wallet address under `arg0` and the wallet address of the 2nd account to whom you’d want to share your tokens under `arg1`.
- Enter the amount of Meta Coins you’d want to transfer under `arg2`.
- Click run and authorize the transaction when prompted.

![aptos08-ezgif.com-resize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%204%20Deploy%20Your%20Token/Lesson%208%20Deploy%20Your%20First%20Fungible%20Token%20on%20Aptos/aptos08-ezgif.com-resize.gif?raw=true)

And there you go, it’s that easy to create your Token on the Aptos Network and perform all the operations you’d want to perform.

### That’s a Wrap

Great job, everyone! 🎉 We've successfully deployed our contract, bringing our dApp to life on the blockchain. With our token ready for action, it's time to tinker around and show off your token.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/4.%20Deploy%20Your%20Token/8.%20Deploy%20Your%20First%20Fungible%20Token%20on%20Aptos.md

Deploy Your First Fungible Token on Aptos

# 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 and how it can empower you in the world of blockchain development.

## What We Covered

- **Introduction:** Got an overview of what we will build and the course structure.
- **Understanding Fungible Asset Token Standard:** We understood the token standards Aptos has for us and how can we utilize them to create our token contract.
- **Getting Started with Development:** Learnt how to set up our development environment using the Aptos CLI. We installed the necessary tools and created a wallet.
- **Create Token Contract:** We created a Token Contract with the following key functionalities:
    - mint, transfer, burn, deposit, withdraw, freeze_account, unfreeze_account
- **Deploy and Interact:** We learned how to deploy our contract to the Aptos testnet and interact with it.

Yes, we did this all!

![Frame 3560406.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%205%20Let%E2%80%99s%20Wrap%20It%20Up/Lesson%209%20Let%E2%80%99s%20Wrap%20It%20Up/Frame_3560406.gif?raw=true)

## ⚒️ A small yet important request

Here is 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/stacks-course) and [LinkedIn](https://bit.ly/stacks-course-linkedin) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos. ✨

## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Aptos%20C3%20Create%20a%20Fungible%20Token%20on%20Aptos/5.%20Let%E2%80%99s%20Wrap%20It%20Up/9.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Create a Fungible Token on Aptos

Embark on a thrilling journey to build a Rock Paper Scissors dApp on the Aptos blockchain! This course is your gateway to mastering Aptos development while creating a fun and engaging project. From setting up your development environment to deploying your completed dApp, you'll gain hands-on experience with Move programming, smart contract interactions, and the Aptos ecosystem. Learn to leverage constants, variables, and functions to create a dynamic game experience. Understand game state management and deploy your dApp with confidence. Whether you're a beginner or have some Aptos knowledge, this course will equip you with the skills to succeed. Get ready to dive into the world of Aptos development and build your first dApp today!

# What Are We Building Today

GM everyone! ☀️ We’re super excited to kick off the fourth, yes fourthhh course in our detailed series on Aptos for developers here on Metaschool. First things first, let’s give you a big round of applause for completing the THREE courses on Metaschool Woohoo! 🎉

Pro move: Savvy blockchain enthusiasts know the value of following project repos on [GitHub](https://github.com/aptos-labs). It's a great way to stay ahead of the curve and potentially catch some interesting opportunities like airdrop maybe!

![aptos-c4-l1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%201%20What%20Are%20We%20Building%20Today/aptos-c4-l1.gif?raw=true)

We know that Aptos is a layer-1 blockchain boasting over 3.9 million monthly active users and more than 983 million transactions to date. With over 170 projects spanning various sectors such as DeFi, NFT tooling, gaming, wallets, stablecoins, and marketplaces, Aptos is a vibrant ecosystem. We are excited to assist you in launching another of your projects on the Aptos platform.

We’ve delved into the Aptos blockchain and mastered its programming language basics. We’ve even built a calculator and a fungible token on Aptos! Now, it's time to take things to the next level with an exhilarating challenge. Get ready to unleash your creativity and skills as we dive into developing an advanced project: a thrilling game of Rock, Paper, Scissors!

Just for your excitement, I have added a GIF that shows how we will interact with our token. But [here’s the vercel link](https://rock-paper-scissors-nzp4.vercel.app/) too so you can interact live with the dApp.

![06.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%201%20What%20Are%20We%20Building%20Today/06.gif?raw=true)

## The Aptos Move contract

<a href=" https://youtu.be/x3J3RyOWO0g" target="_blank">
<img src="https://github.com/0xmetaschool/Learning-Projects/blob/966aafe879f1a03df577907f7e4d8abfa74f47b9/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%201%20What%20Are%20We%20Building%20Today/Aptos%20C4%20thumbnail.png?raw=true" alt="Watch the video" />
</a>

But why build a game contract, you ask? Buckle up, because here's why:

- **Hands-on learning:** Writing a contract is an engaging and practical way to grasp Aptos blockchain concepts.
- **Deployment and interaction:** The excitement doesn't stop at coding! You'll deploy your contract onto Aptos, interact with it on the Explorer, and see your code come to life in a decentralized environment.

## Features of the game contract

This course will equip you with the knowledge and skills to build the following functionalities of a rock-paper-scissors game contract on Aptos Move:

- **Initialization of game state**: It manages the initialization of the game for a user, setting up a structure if it doesn't already exist for the user.
- **Random computer selection**: It utilizes the Aptos `randomness` module to generate a random number between 0 and 2, corresponding to "Rock", "Paper", or "Scissors".
- **Gameplay execution**: It manages the user's ability to play by providing their selection (rock, paper, or scissors). It compares the user's selection against the computer's random selection to determine the outcome (Win, Lose, Draw).
- **Outcome storage:** The outcome is stored for each game.
- **Reusability**: The game can be played multiple times by the same user, updating the result each time a new duel is initiated.

## Course overview

We will:

1. Do a quick run-through of what we have covered so far.
2. Get your tools and workspace ready for development.
3. Build the foundations of the contract.
4. Add functionalities for setting up the game and game state management.
5. Deploy and Interact with the contract on Aptos Testnet Explorer.
6. Add frontend and interact with the game in real time.

## Who exactly should take this course?

This course is for  Web3 developers who wish to dive deeper into the Aptos world and have completed our first three (beginner) courses on Aptos. 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?

As a developer, you will be getting the following outcomes when you complete this course:

1. Utilize Move to build on Aptos
2. Build Rock-Paper-Scissors Game Contract on Aptos
3. Claim your NFT upon course completion

## Proof of completion

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

![Frame 3560411.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%201%20What%20Are%20We%20Building%20Today/Frame_3560411.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/C4%20Rock%20Paper%20Scissor%20on%20Aptos/1.%20Getting%20started/1.%20What%20Are%20We%20Building%20Today.md

# Quick Overview of Aptos world

Hey there! Welcome back! Let’s onboard our journey of building the rock-paper-scissors game. But first, let’s revise a few concepts from our previous courses. No time for waiting, let’s just jump right into it.

> **If you are confident that you do not need any revision, just move on to the next lesson after completing the assignment. We believe in you!**
> 

## Move it or lose it: Why Move?

Born from Facebook's Diem project and based on the Rust programming language, Move is ideal for building dApps. Aptos Labs adopted and optimized Move for their blockchain, focusing on dialects and functionalities specific to the Aptos environment. Despite these optimizations, Aptos Move remains highly similar to core Move (around 70-80%), making the transition smooth for existing Move developers.

We dive into the fascinating world of Move—your ticket to building secure, reliable, and awesome smart contracts! Move prioritizes safety with static typing and a resource-oriented approach, ensuring memory safety and preventing common vulnerabilities. It treats digital assets as special resource types, allowing strict control over ownership and transfer on the blockchain. Compiling to bytecode for direct execution by the blockchain enhances efficiency and security. Additionally, Move’s modular design promotes code reusability and better organization for complex smart contracts.

![aptos-c4-l2.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%202%20Quick%20Overview%20of%20Aptos%20world/aptos-c4-l2.jpg?raw=true)

## What was the need for Move?

In one word: Security. Since 2020, the web3 ecosystem has lost nearly $8 billion to hacks and attacks. Move is designed to prevent common security flaws like reentrancy attacks and integer overflows, prevalent in other smart contract languages. When building decentralized apps (dApps), security and reliability are crucial. Aptos Move helps prevent these issues through key features such as resource-centric design, enforced scarcity, granular access control, and formal verification, ensuring that dApps are secure and reliable by design.

## Aptos asset standard

Fungible tokens (FTs) and non-fungible tokens (NFTs) are the cornerstone of the web3 space, each serving unique purposes. FTs are identical and interchangeable tokens akin to dollar bills or arcade tokens, where each token holds the same value and properties. In contrast, NFTs are unique digital assets stored on the blockchain, each one distinct and irreplaceable, making them ideal for representing collectibles, artworks, and even real-world items.

![Fungible Tokens (FTs) and Non-Fungible Tokens (NFTs).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%202%20Quick%20Overview%20of%20Aptos%20world/Fungible_Tokens_(FTs)_and_Non-Fungible_Tokens_(NFTs).png?raw=true)

The Aptos blockchain supports creating both FTs and NFTs through its defined standards. The Aptos Fungible Asset Standard is used for regular tokens, tokenized real-world assets, and in-game assets. The Aptos Digital Asset Standard is an advanced NFT standard that allows organizing NFTs into collections and modifying, transferring, or burning them through custom smart contracts. These standards leverage Move's object model, facilitating easier development and enabling developers to add custom properties to their tokens, thereby speeding up app development and ensuring seamless integration and secure transactions within the Aptos ecosystem.

## That’s a wrap

In this lesson, we covered how Move is optimized by Aptos Labs for their blockchain, retaining similarities to core Move for ease of use. It prioritizes security with features like static typing, resource-oriented design, and bytecode compilation. Aptos also supports fungible and non-fungible tokens through robust standards, ensuring seamless integration and secure transactions.

In the next lesson, we will set up our environment wizard.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/1.%20Getting%20started/2.%20Quick%20Overview%20of%20Aptos%20world.md

Quick Overview of Aptos world

# Set Up the Environment Wizard

Hey there, welcome back! You've been crushing it so far, understanding Aptos Fungible Asset Standard. Now, it's time to take the next step and set up our development environment with all the necessary dependencies.

> **Well, if you have already installed the Petra wallet and Aptos CLI, skip to the next lesson after completing the assignment.**
> 

## Setup Petra Wallet

1. Download the [Petra Aptos Wallet Chrome extension](https://petra.app/).
2. Click the “Create New Wallet” button.
3. Create a password and securely store your recovery phrase, never share it with anyone. Write it somewhere because if you lose it, you will never have a way to recover your account. So be mindful of that.

( Pin the Petra Aptos Wallet extension to your taskbar, coz we’ll be needing it quite often )

![aptos-petra-1-02-create-new-wallet-35b6d39c458c5c1ff6882a496f257cfd.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/aptos-petra-1-02-create-new-wallet-35b6d39c458c5c1ff6882a496f257cfd.png?raw=true)

## Change the network

We will be deploying our code to the Testnet, so we need to change the network to which our wallet is connected. Follow the steps given below to change it:

1. Go to “Settings” which is at the bottom right corner.
2. Click on the “Network”.
3. Select “Testnet”.

And with this, we have successfully changed the network.

![Frame 3560393 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560393_(1).jpg?raw=true)

## Copy the essentials

There are two key essential pieces of information that you’ll require quite often for the purpose of development and deployment. 

1. Wallet Address 
2. Private Key 

Follow the steps given below to copy and save these:

1. Go to “Settings” which is at the bottom right corner.
2. Scroll down and go to “Manage account”.
3. Enter the password for your Petra wallet and click on Next.
4. Copy the wallet address and save it somewhere secure.
5. Click on “Show” under the Private key.
6. Copy the private key and save it somewhere secure.
- Make sure to NEVER SHARE the private key with anyone. This is very private info and if someone gets access to it, they can hack into your account easily. So stay careful and safe!

![Frame 3560394 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560394_(1).jpg?raw=true)

## Fund the wallet

Here we have another important step to do and that is to fund the wallet. We need money to deploy our code so let’s ask for some fake money. Aptos deals in APT coins.

Click on the “Faucet” button and you will get 1 APT. Well, we clicked it twice to get 2 APT 😇. 

![Frame 3560395 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560395_(1).jpg?raw=true)

## Installation on System

I’ll tell you step-by-step installation for your operating system (OS) which might be Mac, Linux, or Windows. So, opt for the OS you are using, and follow the steps. 

### Installation on Mac

![Frame 3560400 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560400_(2).jpg?raw=true)

1. First, you need a `brew` package. The `brew` allows you to install the packages on Apple easily. Open a terminal on your Mac and run the following command. It will ask for your laptop’s password, provide it, and continue with the installation.
    
    ```
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
    ```
    
2. Open a new terminal and run the following commands:
    
    ```
        brew update
        brew install aptos
    ```
    
3. Now restart the terminal or open another terminal and run the following command to verify if the CLI is installed.
    
    ```
       aptos help
    ```
    

How easy was it~ 

> **Well, if you are a Mac user, the installation part is done, move to the next lesson.**
> 

### Installation on Linux

![Frame 3560401 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560401_(1).jpg?raw=true)

Before starting, just a little heads up: The set of instructions that we’ll discuss are of Ubuntu-based systems and anyone using a different Linux distribution can use their native package managers to install the same dependencies.

Open the terminal and run the following command to install the package. It will ask for your laptop’s password so provide it.

```
sudo install apt-get
```

Aptos peeps suggest that the best and easiest way to install the Aptos CLI tool is through Python script. So let’s install it by running the following command:

```
sudo apt-get install python
```

It will install the latest version of the python. You need a 3.6+ version. You can verify it using **`python --version`. 

Next, you have to ensure that you can use Python in every terminal so to do that you add the path where Python is installed to an environment variable called `PATH`. The variable `PATH` instructs Linux to the directories where it can search for the packages.

So let’s add Python to your `PATH`:

- Run `which python`, it tells where python has been installed on the system i.e., it gives you the path.
- Now run `export PATH=$PATH:/path/to/python` to add the python path to your variable.
- Now install `curl` and then install Aptos CLI using the following commands:
    
    ```
    sudo apt-get install curl
    curl -fsSL "https://aptos.dev/scripts/install_cli.py" | python3
    ```
    
- Or you can use `wget` which is a tool to download the files from the internet from the terminal directly. You can install Aptos CLI using the following commands:
    
    ```
    sudo apt-get install wget
    wget -qO- "https://aptos.dev/scripts/install_cli.py" | python3
    ```
    
- Now restart the terminal or open another terminal and run the following command to verify if the CLI is installed.
    
    ```
       aptos help
    ```
    

> **Awesome! You are good to go to the next lesson!**
> 

### Installation on Windows

![Frame 3560399 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-aptos-c3/Section%202%20Set%20Up%20Dev%20Environment/Lesson%203%20Set%20Up%20the%20Environment%20Wizard/Frame_3560399_(1).jpg?raw=true)

You can install the Aptos CLI using the python. So first install Python by following the steps given:

1. Visit the [Python website and download the package](https://www.python.org/downloads/windows/) according to your system architecture.
2. Check your Downloads folder to see the package. 
3. Install the package and you’re set up for python.

Now follow the steps given below to install the CLI:

1. Open PowerShell using the Start Menu.
2. Run the following command:
    
    ```
    iwr "https://aptos.dev/scripts/install_cli.py" -useb | Select-Object -ExpandProperty Content | python3
    ```
    
3. The command’s output will show you a command to set the `PATH` variable, make sure to run it.
4. Run the following command to verify if the CLI is installed.
    
    ```
       aptos help
    ```
    


## That’s a wrap

Whew! We’ve conquered the installation phase, and now it’s time to dive into the fun stuff! Get ready because in the next lesson, we’re rolling up our sleeves to create a project for our fungible token. Let’s bring those coding dreams to life! 


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/2.%20Set%20Up%20Dev%20Environment/3.%20Set%20Up%20the%20Environment%20Wizard.md

# Set Up the Rock Paper Scissor Project on Move

Alright! We've set up our wallet and the Aptos-cli, and now it's time to start cooking up our rock-paper-scissors dApp. In this lesson, we'll guide you step-by-step on setting up your project so you can deploy your smart contract to the Aptos Network. Later, you'll learn how to interact with it using the front end. So let's get 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/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%204%20Set%20Up%20the%20Rock%20Paper%20Scissor%20Project%20on%20Move/Frame_3560408.jpg?raw=true)

1. **Node.js & npm (or yarn):** Node Js is the engine that powers your JavaScript code, even outside of a web browser. We need this for our frontend part.
    - **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 need help deciding which one, npm is a great starting point.
    - **Verify success:** Open your terminal (or command prompt) and type the following commands:
        
        ```
        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 code 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.
    - Install [Move Analyzer](https://marketplace.visualstudio.com/items?itemName=move.move-analyzer). This extension provides essential language support for the Move programming language. Though it’s technically optional, we recommend installing it.
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.
4. **Git CLI:** It allows you 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.
    
    ![Screen Recording 2024-07-15 at 11.44.49 AM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%204%20Set%20Up%20the%20Rock%20Paper%20Scissor%20Project%20on%20Move/Screen_Recording_2024-07-15_at_11.44.49_AM.gif?raw=true)
    

Awesome, you are all set!! Good job!

## Your rock-paper-scissors project

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/rock-paper-scissors-aptos-dapp.git --clone
cd rock-paper-scissors-aptos-dapp
```

This will clone the boilerplate code of your project onto your system and fork the repository to your Git account as well. And we will change the folder to this cloned repo.

Now run the following command in your terminal:

```
aptos init
```

1. When you run the above command, you’ll be prompted to choose a network. Type `testnet` and press Enter.
2. Next, you’ll be asked to provide the private key. Use the same private key you copied and saved from the previous lesson. Paste it into the terminal.

![aptos-c4-l4.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%204%20Set%20Up%20the%20Rock%20Paper%20Scissor%20Project%20on%20Move/aptos-c4-l4.jpg?raw=true)

## That’s a wrap

Wow, we've been on a wild ride, haven't we? You've been absolutely stellar in crafting your project. Now, in our next lesson, get ready to dive headfirst into setting up our frontend part of dApp.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/2.%20Set%20Up%20Dev%20Environment/4.%20Set%20Up%20the%20Rock%20Paper%20Scissor%20Project%20on%20Move.md

Set Up the Rock Paper Scissor Project on Move

# Creating the UI

Alrighty! So now that we have successfully set up our development environment, it’s time to switch things up a bit. Instead of providing you with a ready-made boilerplate, we're going to build it from the ground up together. So, let's roll up our sleeves and get started! 💪

## Frontend prep-work

In the Git repository you've forked, we'll set up our React project right in the root directory. Simply, run the `create-react-app` command in the root directory to set up a new React project with a standard development environment. Let's get started!

```
npx create-react-app interface --template typescript
```

Once you've set up the project, your React project structure should look like this:

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%205%20Creating%20the%20UI/Untitled.png?raw=true)

## Adding wallet support

To play the game, users need to connect their wallet to the dApp. Once connected, they alone will be taken to the Game UI. So let’s add in wallet support for our dApp.

![01.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%205%20Creating%20the%20UI/01.gif?raw=true)

To get everything set up, just install `@aptos-labs/wallet-adapter-react` for managing wallet connections and `petra-plugin-wallet-adapter` for the wallet functionalities.

```
cd interface
npm install @aptos-labs/wallet-adapter-react petra-plugin-wallet-adapter
```

Locate your `index.tsx` file. Typically, it should be found at `interface\src\index.tsx`. Now we need to wrap the `App` component with the `AptosWalletAdapterProvider`. But first, let's prepare an array that contains instances of `PetraWallet` after we import it. Add the following lines to the file.

```tsx
// Import Petra-wallet adapter
import { PetraWallet } from "petra-plugin-wallet-adapter";

// Create wallet objects
const wallets = [
  new PetraWallet()
];
```

Finally, wrap the `App` component with the `AptosWalletAdapterProvider` component. Use the `plugins` prop to pass the `wallets` array and set `autoConnect` to `false`. Here’s how the final code should look :

```tsx
import React from 'react';
import ReactDOM from 'react-dom/client';
import './index.css';
import App from './App';
import reportWebVitals from './reportWebVitals';
import {AptosWalletAdapterProvider} from "@aptos-labs/wallet-adapter-react";
import { PetraWallet } from "petra-plugin-wallet-adapter";

const wallets = [
  new PetraWallet()
];

const root = ReactDOM.createRoot(
  document.getElementById('root') as HTMLElement
);
root.render(
  <React.StrictMode>
    <AptosWalletAdapterProvider plugins={wallets} autoConnect={false}>
	    <App />
    </AptosWalletAdapterProvider>
  </React.StrictMode>
);
reportWebVitals();
```

## Creating the wallet connection UI

First, you'll need to install some packages. We're using `styled-components` for styling and `@aptos-labs/wallet-adapter-ant-design` for the wallet connection UI. You can install them with these commands:

```
npm install styled-components @aptos-labs/wallet-adapter-ant-design
npm install --save @types/styled-components
```

Now head out to `App.tsx` in the same `*src`* folder. To get started import the `WalletSelector` component from `@aptos-labs/wallet-adapter-ant-design` package and it’s CSS file.

```tsx
import { WalletSelector } from "@aptos-labs/wallet-adapter-ant-design";
import "@aptos-labs/wallet-adapter-ant-design/dist/index.css";
```

We will be also taking advantage of the `useWallet` hook. This hook provides a simple way to access the wallet's connection status and related information. Specifically, it gives us access to:

- `connected`: A Boolean value indicating whether the wallet is connected.
- `account`: The account details of the connected wallet.
- `signAndSubmitTransaction`: A function to sign and submit transactions using the connected wallet.

By using this hook, we can easily determine if a wallet is connected and display an appropriate message to the user. The rest will come in handy soon in the next lessons.

Finally, we render our component. The `WalletWrapper` contains the `WalletSelector`, which is a ready-made UI component for connecting the wallet. Below that, we conditionally render a message based on whether the wallet is connected. If it's connected, we show "Wallet is connected"; if not, we prompt the user to connect their wallet.

```tsx
import React from "react";
import { WalletSelector } from "@aptos-labs/wallet-adapter-ant-design";
import { useWallet } from "@aptos-labs/wallet-adapter-react";
import styled from "styled-components";
import "@aptos-labs/wallet-adapter-ant-design/dist/index.css";

const WindowWrapper = styled.div`
  display: flex;
  flex-direction: column;
  justify-content: center;
  align-items: center;
  height: 100vh;
  background-color: #f0f0f0;
`;

const WalletWrapper = styled.div`
  position: absolute;
  right: 10px;
  top: 10px;
  background-color: #f0f0f0;
`;

const App: React.FC = () => {
  const { connected } = useWallet();

  return (
    <WindowWrapper>
      <WalletWrapper>
        <WalletSelector />
      </WalletWrapper>
      {connected ? (
        <h1>Wallet is connected</h1>
      ) : (
        <h1>Please connect your wallet to continue</h1>
      )}
    </WindowWrapper>
  );
};

export default App;

```

And that's it! This simple setup lets users connect their wallet and see an immediate indication of the connection status. It's a neat and straightforward way to get started with wallet integration in your React app.

## First launch

Launch the react app by running the following command : 

```
npm start
```

Once the App spins up in the browser you can test whether the Wallet connection works as intended by clicking on the *Connect Wallet* and selecting Petra Wallet in the popup window. You should be able to see the “Wallet is Connected” message in your App.

![03.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%205%20Creating%20the%20UI/03.gif?raw=true)

## That’s a wrap

And that's it! This simple setup lets users connect their wallet and see an immediate indication of the connection status. It's a neat and straightforward way to get started with wallet integration in your React app. We’ll see how to fetch and submit data to the Aptos Blockchain in the upcoming lessons.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/2.%20Set%20Up%20Dev%20Environment/5.%20Creating%20the%20UI.md

Creating the UI

# Setting Up the Game

Welcome! You’re doing great in setting up all the essentials. Now it’s coding time. Let's dive deeper into the constants, and variables, and create a game function. These are crucial for our dApp to function correctly and efficiently. 

Time to finally implement our rock-paper-scissors game. So why wait, let’s go~

![aptos-c4-l6.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%206%20Setting%20up%20the%20Game/aptos-c4-l6.gif?raw=true)

## Quick checkout

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

```
git checkout origin/boilerplate_02
```

Navigate to the `sources/RockPaperScissors.move` file and let’s go through the code. 

Here’s the complete code mentioned in `sources/RockPaperScissors.move` file:

```tsx
module metaschool::RockPaperScissors_01 {
    use std::string::{String,utf8};
    use std::signer;

    struct DuelResult has key
    {
        computer_selection: String,
        duel_result: String
    }

    public entry fun createGame(account: &signer)acquires DuelResult { 
        if (exists<DuelResult>(signer::address_of(account))){
            let result = borrow_global_mut<DuelResult>(signer::address_of(account));
            result.computer_selection = utf8(b"New Game Created");  
            result.duel_result = utf8(b"Game not yet played");
        }
        else {
            let result = DuelResult { computer_selection: utf8(b"New Game Created") , duel_result:utf8(b"Game not yet played")};
            move_to(account, result);
        }
    }
}
```

## Code explanation

The code explanation is:

```tsx
module metaschool::RockPaperScissors_01 {
```

- This line defines a new Move module named `RockPaperScissors_01` within the `metaschool` package.

```tsx
    use std::string::{String,utf8};
    use std::signer;
```

- These lines import the `String` and `utf8` utilities from the standard library for handling strings, and the `signer` module for handling account signers.

```tsx
    struct DuelResult has key
    {
        computer_selection: String,
        duel_result: String
    }
```

- This block defines a struct named `DuelResult` with two string fields: `computer_selection` and `duel_result`. The `has key` attribute indicates that instances of this struct can be stored in the global storage associated with a specific address.

```tsx
    public entry fun createGame(account: &signer) acquires DuelResult {
```

- This line defines a public entry function named `createGame` that takes a reference to a `signer` type account as a parameter. The `acquires DuelResult` clause indicates that this function will access and modify `DuelResult` resources in the global storage.

```tsx
        if (exists<DuelResult>(signer::address_of(account))){
```

- This line checks if a `DuelResult` resource already exists at the address of the given account.

```tsx
            let result = borrow_global_mut<DuelResult>(signer::address_of(account));
```

- If a `DuelResult` resource exists, this line borrows it mutably from the global storage.

```tsx
            result.computer_selection = utf8(b"New Game Created");
            result.duel_result = utf8(b"Game not yet played");
```

- These lines set the `computer_selection` field to "New Game Created" and the `duel_result` field to "Game not yet played" in the borrowed `DuelResult` resource.

```tsx
        }
        else {
            let result = DuelResult { computer_selection: utf8(b"New Game Created"), duel_result: utf8(b"Game not yet played")};
            move_to(account, result);
        }
    }
}
```

- This line starts an `else` block that runs if a `DuelResult` resource does not already exist at the account's address.
- This line creates a new `DuelResult` instance with the fields `computer_selection` and `duel_result` set to "New Game Created" and "Game not yet played", respectively.
- This line moves the new `DuelResult` instance to the global storage at the address of the given account.

## Deploy your dApp

Let’s go ahead and deploy the contract using the CLI. 

### Update `Move.toml`

First things first, we need to add our wallet address. So go to the `Move.toml` and update `Replace_with_your_wallet_address_🔑` with your wallet address.

![aptos-c4-l6.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%206%20Setting%20up%20the%20Game/aptos-c4-l6.jpg?raw=true)

### Deploy the code

Now open a terminal in the `rock-paper-scissors-aptos-dapp` folder and run the following command:

```
aptos move compile
```

The command will essentially compile our code and if the compilation is successful that means our code is mostly error-free and ready to be pushed to a network. The output will look like this:

![aptos-c4-l6 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%206%20Setting%20up%20the%20Game/aptos-c4-l6_(1).jpg?raw=true)

### Publish the contract

The following command will publish our code to the Aptos testnet. While running the command, it will prompt you regarding the transaction fee payment, just add a ‘yes’ there.

```
aptos move publish
```

And once that is done, the CLI will automatically publish the code to the Aptos testnet. The output will look like this:

![aptos-c4-l6 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%206%20Setting%20up%20the%20Game/aptos-c4-l6_(2).jpg?raw=true)

We are done with the contract part. Let’s explore how to use it in the frontend in the next lesson.

## That’s a wrap

Well, it’s a wrap! You did great in understanding the initial structure of our code. We compiled and published that code too. Get ready for the next lesson where we will implement the frontend logic.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/3.%20Building%20rock%20paper%20scissor%20game/6.%20Setting%20up%20the%20Game.md

Setting Up the Game

# Setting Up the Game UI

Welcome! You did awesome in the coding time. Let's dive into the frontend part and implement our rock-paper-scissors game. Time for some action~ So why wait, let’s go~

## Sending data over to the chain

Now that we have spun up the function for creating the game, Let’s make our React App able to invoke this function so that we can go in and implement the duel logic later.

Remember the `useWallet()` Hook from the UI lesson? To interact with the Aptos Blockchain, we will need to sign and send transactions to the blockchain network for processing and confirmation. That’s where the `signAndSubmitTransaction` function is provided by the `useWallet()` Hook. 

```tsx
const { account, connected, signAndSubmitTransaction } = useWallet();
```

Next, we need the `InputTransactionData` to define the structure of transaction data used to interact with blockchain smart contracts, specifying functions and arguments for execution. let’s get it imported from `@aptos-labs/wallet-adapter-react` package.

```tsx
import {
  InputTransactionData,
  useWallet,
} from "@aptos-labs/wallet-adapter-react";
```

We’ve already created an empty function called `toggleActiveState` that will kick in when you hit "Start Game". Let’s use `InputTransactionData` to create a payload—it's like a little package of data that tells the blockchain what to do and what arguments to use (which are stored as an array).

```tsx
  const toggleActiveState = async () => {
	    const payload: InputTransactionData = {
        data: {
          function: `${moduleAddress}::${moduleName}::createGame`,
          functionArguments: [],
        },
      };
  };
```

This payload includes important stuff like the module address (`moduleAddress`) and module name (`moduleName`). These details are crucial because they pinpoint exactly which function should run on the blockchain. To keep things tidy and flexible, we'll store these values in an `.env` file as environment variables. This makes it easy to tweak them as needed and keeps our setup clean and organized.

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%207%20Setting%20Up%20the%20Game%20UI/Untitled.png?raw=true)

Now we can finally use the `signAndSubmitTransaction` function to execute the function. Let’s also add in some edge case checks and initialize our state variables.

```tsx
const toggleActiveState = async () => {
    setIsActive(!isActive);
    if (!account) return;
    if (!isActive) {
      console.log("Toggling active state: " + isActive);
      const payload: InputTransactionData = {
        data: {
          function: `${moduleAddress}::${moduleName}::createGame`,
          functionArguments: [],
        },
      };
      const response = await signAndSubmitTransaction(payload);
      console.log(response);
    }
    setInput("");
    setResult("");
    setComputerSelection("");
  };
```

## Let’s test it out

Launch the react app by running the following command : 

```powershell
npm start
```

Once the App spins up again in your browser, connect your wallet and click on the Start game button to initialize the game.

![04.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%207%20Setting%20Up%20the%20Game%20UI/04.gif?raw=true)

Even though we can’t play the game yet, you can use the [Aptos Explorer](https://explorer.aptoslabs.com/?network=testnet) to view the new resource created against your address for our Game.

![05.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%207%20Setting%20Up%20the%20Game%20UI/05.gif?raw=true)

## Pushing it to Git

Make sure you are in `rock-paper-scissors-aptos-dapp` folder.

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

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

## That’s a wrap

Now, with our React app set up to interact with the blockchain, we've tackled how to trigger functions using `signAndSubmitTransaction`, ensuring our game functions as intended. Next, we'll focus on implementing the game logic itself, ensuring our dApp handles player choices and determines the winner seamlessly.

Feeling confident? Great! Let's keep pushing forward and bring our rock-paper-scissors game to life. Happy coding!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/3.%20Building%20rock%20paper%20scissor%20game/7.%20Setting%20Up%20the%20Game%20UI.md

Setting Up the Game UI

# Game State Management

Welcome! You did great in writing and understanding the basic contract. Now it’s time to understand an important concept of randomness on which the major logic of our game depends. Let’s explore it!

## Understanding Aptos roll: The unpredictable lottery for dApps

Aptos Roll provides a secure way to generate random numbers on the Aptos blockchain. This is crucial for decentralized applications (dApps) that rely on randomness, such as lotteries, games, and other applications needing unbiased random outcomes.

![aptos-c4-l7 (1).gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%208%20Game%20State%20Management/aptos-c4-l7_(1).gif?raw=true)

> **The code and information have been referred from Aptos’ official [documentation](https://aptos.dev/en/build/smart-contracts/randomness) on Aptos roll.**
> 

### What it does: A quick example

In a centralized system, picking a random winner from a list of participants is straightforward. For instance, using Python, you could simply use `random.randint(0, n-1)` to get a random index. However, achieving the same in a decentralized system like Aptos without a trusted server is challenging.

### Insecure methods of generating random numbers

Before the introduction of Aptos Roll, developers often resorted to insecure methods for generating random numbers. For example:

```
module module_owner::lottery {
    struct LotteryState {
        players: vector<address>,
        winner_idx: std::option::Option<u64>,
    }

    fun load_lottery_state_mut(): &mut LotteryState {
        // ...
    }

    entry fun decide_winner() {
        let lottery_state = load_lottery_state_mut();
        let n = std::vector::length(&lottery_state.players);
        let winner_idx = aptos_framework::timestamp::now_microseconds() % n;
        lottery_state.winner_idx = std::option::some(winner_idx);
    }
}
```

This approach is insecure for several reasons:

1. **Transaction timing**: A malicious user can influence the result by choosing the transaction submission time.
2. **Validator influence**: A malicious validator can bias the outcome by selecting which block includes the `decide_winner` transaction.

### Secure but complex external randomness

Some developers turned to external randomness sources like drand, but this introduces complexity:

1. Participants agree to use a future randomness seed.
2. Once the seed is revealed, clients fetch it and derive the winner locally.
3. One participant submits the seed and the winner is on-chain.

## Achieving simplicity and security with Aptos roll

With Aptos Roll, generating secure random numbers is straightforward. Here's how you can use it effectively:

### 1. Making randomness-dependent entry functions compliant

Annotate entry functions that depend on randomness with `#[randomness]` to make them compliant:

```
#[randomness]
entry fun decide_winner() {
    let lottery_state = load_lottery_state_mut();
    let n = vector::length(&lottery_state.players);
    let winner_idx = aptos_framework::randomness::u64_range(0, n);
    lottery_state.winner_idx = std::option::some(winner_idx);
}
```

This attribute ensures that the function is recognized by the Aptos VM and can safely use the randomness API.

### 2. Calling the API

Use the randomness functions provided by the API. Here are some examples:

```
module aptos_framework::randomness {
    // Generates a number uniformly at random.
    fun u8_integer(): u8 {}
    fun u16_integer(): u16 {}
    // Generates a number `[min_incl, max_excl)` uniformly at random.
    fun u8_range(min_incl: u8, max_excl: u8): u8 {}
    fun u16_range(min_incl: u16, max_excl: u16): u16 {}
    // Generates a sequence of bytes uniformly at random.
    fun bytes(n: u64): vector<u8> {}
    // Generate a permutation of `[0, 1, ..., n-1]` uniformly at random.
    fun permutation(n: u64): vector<u64> {}
}
```

These functions allow you to generate random numbers and sequences, which can be used in various dApp scenarios.

### 3. Security considerations

While the randomness API is secure, developers must be aware of potential vulnerabilities like undergasing attacks. Here are some tips:

- Ensure the gas cost of your functions is independent of the randomness outcome.
- Only allow trusted admins to execute randomness transactions if applicable.
- Make the path that is most beneficial have the highest gas cost to prevent attackers from biasing the outcome.

## How to use Aptos randomness API
Let's find out how to use the Aptos randomness API in your code.

### 1. Supported networks

- The API is enabled on devnet and testnet, with mainnet support coming soon.

### 2. Preventing undergasing attacks

- Ensure the gas cost of your functions is independent of the randomness outcome.
- Only trusted admins should execute randomness transactions if applicable.

### Example API usage

A complete list of API functions for generating random numbers of various types is available. Here’s an overview:

```
module aptos_framework::randomness {
    fun u8_integer(): u8 {}
    fun u16_integer(): u16 {}
    fun u8_range(min_incl: u8, max_excl: u8): u8 {}
    fun u16_range(min_incl: u16, max_excl: u16): u16 {}
    fun bytes(n: u64): vector<u8> {}
    fun permutation(n: u64): vector<u64> {}
}
```

Aptos Roll simplifies the generation of secure random numbers for dApps on the Aptos blockchain, providing a necessary tool for developers to create fair and secure applications. However, developers must remain vigilant against potential attacks and design their contracts accordingly.

We will use this feature to implement the logic of our game. So let’s begin~ 

## Quick checkout

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

```
git checkout origin/boilerplate_03
```

Don't worry, all the code we’ve written so far will be present in the project. Navigate to the `sources/RockPaperScissors.move` file. The complete code of `RockPaperScissors.move` file is [here](https://github.com/0xmetaschool/rock-paper-scissors-aptos-dapp/blob/boilerplate_03/sources/RockPaperScissors.move).

We will dive into the features and functionalities that we have added.

## Code explanation

First, we will add the `randomness` module to our code.

```
use aptos_framework::randomness;
```

Next, we will define the `duel` function.

```
#[randomness]
entry fun duel(account: &signer, user_selection: String) acquires DuelResult {
```

- `#[randomness]` is an attribute that indicates this function will use randomness.
- `entry fun duel` defines a public entry function named `duel` that can be called externally.
- The function takes two parameters:
    - `account: &signer`: A reference to the signer's account.
    - `user_selection: String`: A string representing the user's selection (Rock, Paper, or Scissors).
- `acquires DuelResult` specifies that this function will access and modify `DuelResult` resources in the global storage.

```
let random_number = randomness::u64_range(0, 3); // 3 is exclusive
```

- This line generates a random number between 0 and 2 (inclusive) using the `randomness::u64_range` function. The `3` is exclusive, meaning the possible values are 0, 1, or 2.

```
let result = borrow_global_mut<DuelResult>(signer::address_of(account));
```

- This line borrows the `DuelResult` resource associated with the account's address from the global storage, allowing it to be modified.

```
if(random_number==0)
{
    result.computer_selection = utf8(b"Rock");
}
else
{
    if(random_number==1)
    {
        result.computer_selection = utf8(b"Paper");
    }
    else
    {
        result.computer_selection = utf8(b"Scissors");
    }
};
```

- This block sets the `computer_selection` field of the `DuelResult` resource based on the generated random number:
    - If `random_number` is 0, the computer's selection is "Rock".
    - If `random_number` is 1, the computer's selection is "Paper".
    - If `random_number` is 2, the computer's selection is "Scissors".

```
let computer_selection = &result.computer_selection;
```

- This line creates a reference to the `computer_selection` field of the `DuelResult` resource.

```
if (user_selection == *computer_selection) {
    result.duel_result = utf8(b"Draw"); // Draw
} else if ((user_selection == utf8(b"Rock") && *computer_selection == utf8(b"Scissors")) ||
           (user_selection == utf8(b"Paper") && *computer_selection == utf8(b"Rock")) ||
           (user_selection == utf8(b"Scissors") && *computer_selection == utf8(b"Paper"))) {
    result.duel_result = utf8(b"Win"); // User wins
} else {
    result.duel_result = utf8(b"Lose"); // Computer wins
}
```

- This block determines the result of the duel based on the user's selection and the computer's selection:
    - If the user's selection matches the computer's selection, the result is a draw.
    - If the user's selection beats the computer's selection (according to Rock-Paper-Scissors rules), the result is a win for the user.
    - Otherwise, the result is a win for the computer.
- The `duel_result` field of the `DuelResult` resource is updated accordingly:
    - "Draw" if it's a tie.
    - "Win" if the user wins.
    - "Lose" if the computer wins.

Lastly, we have a `get_result` function that retrieves the computer's selection and the duel result for a given user's account. It takes the signer's account as a parameter, borrows the `DuelResult` resource associated with the account's address, and returns a tuple containing the computer's selection and the duel result.

```
    public fun get_result(account: &signer): (String, String) acquires DuelResult {
        let result = borrow_global<DuelResult>(signer::address_of(account));
        (result.computer_selection, result.duel_result)
    }
```

Whew! We are doneeeeeee with the code! Let’s deploy and see how it works.

## Deploy your dApp

Let’s deploy the contract using the CLI. Open a terminal in the `rock-paper-scissors-aptos-dapp` folder and run the following command:

```
aptos move compile
```

The command will essentially compile our code and if the compilation is successful that means our code is mostly error-free and ready to be pushed to a network. The output will look like this (ignore the warnings):

![aptos-c4-l7.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%208%20Game%20State%20Management/aptos-c4-l7.jpg?raw=true)

## Publish the contract

The following command will publish our code to the Aptos testnet. While running the command, it will prompt you regarding the transaction fee payment, just add a ‘yes’ there.

```
aptos move publish
```

And once that is done, the CLI will automatically publish the code to the Aptos testnet. The output will look like this (ignore the warnings):

![aptos-c4-l7 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%208%20Game%20State%20Management/aptos-c4-l7_(2).jpg?raw=true)

## That’s a wrap

Woohoo! You did great! We implemented the complete logic of our game and deployed it. In the next lesson, we will complete the frontend and interact with it. Stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/3.%20Building%20rock%20paper%20scissor%20game/8.%20Game%20State%20Management.md

Game State Management

# Game State Management UI

Hey hero! Welcome back! So far we have implemented the logic and deployed it too. Now it’s time to add a complete frontend so we can successfully interact with our dApp. Can’t wait? Me too! So let’s dive right into it!

## Fetching data from the chain

Just like we called the `createGame` function in our React app, we can use the same steps to call the `duel` function when triggered by the action buttons.

```tsx
const handleOperationClick = async (operation: string) => {
    setResult("");
    setComputerSelection("");
    if (
      operation === "Rock" ||
      operation === "Paper" ||
      operation === "Scissors"
    ) {
      setInput(` ${operation} `);
      try {
        if (!account) return;
        setTransactionInProgress(true);
        const payload: InputTransactionData = {
          data: {
            function: `${moduleAddress}::${moduleName}::duel`,
            functionArguments: [operation],
          },
        };
        const response = await signAndSubmitTransaction(payload);
      } catch (error) {
        console.error(error);
      } finally {
        setTransactionInProgress(false);
      }
    } else {
      setInput(` ${operation} `);
    }
  };
```

But what about when we need to fetch data from the Aptos blockchain? No worries! We can use the [Aptos TypeScript SDK](https://aptos.dev/en/build/sdks/ts-sdk). This handy SDK has all the classes and functions we need to easily interact with and query the Aptos chain. Follow the steps below to integrate it into your React App.

Stop the local server if it’s already running and then install the SDK in the interface directory using :

```
npm install @aptos-labs/ts-sdk
```

Import the `Aptos` and `AptosConfig` class in your `App.tsx` along with `Network`.

```tsx
import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
```

By default, `Aptos` will interact with the `devnet` network, to set it up with the Testnet, we will use the `AptosConfig` class that we just imported. Let’s then go in and create an instance of Aptos class as well.

```tsx
const aptosConfig = new AptosConfig({ network: Network.TESTNET });
const client = new Aptos(aptosConfig);
```

We can now use the instance of Aptos Class we named `client` and fetch resources using the `getAccountResource` function. This function takes an object as a parameter with the *account address* and *resource type* as its fields.

```tsx
const resultData = await client.getAccountResource({
  accountAddress: account?.address,
  resourceType: `${moduleAddress}::${moduleName}::DuelResult`,
});
```

We can then update our state variable for the result by typecasting the `resultData` to String. The final function will look this the following.

```tsx
  const handleOperationClick = async (operation: string) => {
    setResult("");
    setComputerSelection("");
    if (
      operation === "Rock" ||
      operation === "Paper" ||
      operation === "Scissors"
    ) {
      setInput(` ${operation} `);
      try {
        if (!account) return;
        setTransactionInProgress(true);
        const payload: InputTransactionData = {
          data: {
            function: `${moduleAddress}::${moduleName}::duel`,
            functionArguments: [operation],
          },
        };
        const response = await signAndSubmitTransaction(payload);
        const resultData = await client.getAccountResource({
          accountAddress: account?.address,
          resourceType: `${moduleAddress}::${moduleName}::DuelResult`,
        });
        console.log(resultData);
        setResult(resultData.duel_result.toString());
        setComputerSelection(resultData.computer_selection.toString());
      } catch (error) {
        console.error(error);
      } finally {
        setTransactionInProgress(false);
      }
    } else {
      setInput(` ${operation} `);
    }
  };
```

## Let’s test it out

Launch the react app by running the following command : 

```
npm start
```

Once the app reloads in your browser, connect your wallet and hit the "Start Game" button to get started. Make your move in the rock-paper-scissors game, and after you approve the transaction, the result and the computer's choice will be fetched from the Aptos blockchain.

![06.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/C4%20Rock%20Paper%20Scissor%20on%20Aptos%20Images/Lesson%201%20What%20Are%20We%20Building%20Today/06.gif?raw=true)

## Pushing it to Git

Make sure you are in `rock-paper-scissors-aptos-dapp` folder.

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

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

## That’s a wrap

Congratulations! You've successfully built and deployed a complete rock-paper-scissors game on the Aptos blockchain. Throughout our lessons, we explored how to leverage the on-chain randomness provided by Aptos to ensure fair play and unpredictability in our game. We also saw how to use the Aptos TypeScript SDK to interact with the blockchain seamlessly from our React app. Keep experimenting and exploring the capabilities of Aptos and the TypeScript SDK in your future projects.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/3.%20Building%20rock%20paper%20scissor%20game/9.%20Game%20State%20Management%20UI.md

Game State Management UI

# 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 and how it can empower you in the world of blockchain development.

## What we covered

- **Introduction:** Got an overview of what we will build and the course structure.
- **Overview of Aptos world:** We revised why Aptos, Move, and its features are bringing change to the web3 world.
- **Aptos SDK:** We understood the Aptos SDK support for the frontend part and what features it has for us and how can we utilize them to create our dApp.
- **Getting started with development:** Learnt how to set up our development environment using the Aptos CLI. We installed the necessary tools and created a wallet.
- **Create, deploy, and interact with dApp:** We wrote the contract for our dApp and utilized the randomness feature of Aptos. We deployed it to frontend and interacted with it.

Yes, we did this all! Cheers~

![aptos-c4-l10.gif](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 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://x.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool) as well. 🫶
3. Subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos. ✨

## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/C4%20Rock%20Paper%20Scissor%20on%20Aptos/4.%20Wrap%20up/10.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Warden Protocol

30 days of solidity

Fuel Marathon

Aptos Marathon

Core Marathon

Sui Marathon

Learn to Build on Aptos, Make Your Move

AI Templates

TicTacToeGPT

MockInterviewerGPT

CSSGeneratorGPT

FinanceGPT

LearnLanguageGPT

Castle.ai

FlashcardGPT

DatingCoachGPT

TriviaQuizGPT

CrosswordGPT

AI Tools

Learn to Build on Aptos, Make Your Move