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

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.

![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 [X](https://bit.ly/stacks-course) and [LinkedIn](https://bit.ly/stacks-course-linkedin), it would be a great support. 🫣
4. You can subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos too. ✨
5. 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! 🎉

![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.gif?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.gif?raw=true)

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

1. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/stacks-course) and [LinkedIn](https://bit.ly/stacks-course-linkedin), it would be a great support. 🫣
4. You can subscribe to our [YouTube](https://www.youtube.com/@0xmetaschool) channel for exciting videos too. ✨
5. 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

What Are We Building Today?

# 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.png?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.png?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.gif?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.png?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.jpg?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.gif?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.jpg?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.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, 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.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

![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.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

![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.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, 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.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 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.png?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.png?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.png?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.png?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.gif?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.jpg?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).png?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).gif?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.gif?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.gif?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

Now, let’s get back to the calculator dApp and add the struct. Here’s how we’re doing it.

```
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 c`alculator` 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 data type for 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.

## 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.png?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).png?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.png?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.gif?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).png?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 {

		// 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).gif?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.gif?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 {

		// 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.gif?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. Clone our repository by running the following command :
    
    ```
    git clone https://github.com/0xmetaschool/Building-on-Aptos-boilerplate.git
    cd Building-on-Aptos-boilerplate
    git fetch --all
    git checkout boilerplate_03
    ```
    
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.png?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 public , 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.png?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.png?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.png?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.gif?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.png?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.png?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.png?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.png?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.png?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 Solidity.

## 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.gif?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.png?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 {
    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.gif?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.gif?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::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= "calculator_l12"
    ```
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.gif?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.gif?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.gif?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.gif?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.gif?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.gif?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.gif?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.gif?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.png?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.png?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.png?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.gif?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.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://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

30 days of solidity

Fuel Marathon

Aptos Marathon

Core Marathon

Sui Marathon

Learn to Build on Aptos, Make Your Move

Understand the Fundamentals of Aptos

Introduction to Aptos Platform

What you’ll learn

Start Building on Aptos

What you’ll learn

Expand your skills to build using Aptos Move

Deploying a Fungible Token on Aptos Testnet

Create a Rock, Paper, Scissor Game

Build an end-to-end secure dApp

Building a Contract Management dApp

Learn to Build on Aptos, Make Your Move

Understand the Fundamentals of Aptos

Introduction to Aptos Platform

What you’ll learn

Show Details

Start Building on Aptos

What you’ll learn

Show Details

Expand your skills to build using Aptos Move

Deploying a Fungible Token on Aptos Testnet

Create a Rock, Paper, Scissor Game

Build an end-to-end secure dApp

Building a Contract Management dApp