An in-depth learning track designed for developers to excel in MANTRA Chain, mastering the skills needed to create innovative, compliant dApps for real-world asset tokenization and push the boundaries of decentralized finance.

Mantra

Learn to build the future of finance on MANTRA Chain, a cutting-edge blockchain platform for real-world asset tokenization. This comprehensive course will guide you through the exciting world of real-world assets (RWAs) and their tokenization on the blockchain.  From the innovative Cosmos ecosystem to MANTRA Chain's unique vision and architecture, this course is your all-access pass to becoming a MANTRA expert. Discover how MANTRA Chain is revolutionizing real-world asset tokenization and learn the tools to participate in this new era of onchain finance.

# What are we learning today?

Hey there, future blockchain buff! 🌟 We’re super excited to kick off the first course in the MANTRA Chain learning track. Get ready to dive into the revolutionary world of onchain finance and real-world assets (RWAs). If you’re prepared to ride the wave of the future, you’re in the perfect spot.

Did you know? Active participants in blockchain communities often find themselves rewarded in unexpected ways. Staying connected through GitHub repos is a smart move for any crypto enthusiast. Speaking of which, have you checked out [MANTRA's official repository](https://github.com/MANTRA-Finance) yet?

![https://lh7-us.googleusercontent.com/docsz/AD_4nXey-65XFbaUqLelaoRrjZC9-Rt5DP-ACNSDyX67TgrqI4oWyIZF8P7p9eohfsHbrFjClnrvxs_3gCoDTz1Mm_1o8sikVfD6hhpeHY6qJ3suy08MYfpJ4Ah98bgijP6M8fk9kVpqyY4Y2zBsGgtSyevpb9s?key=5nux_2-mkDEv0d6cByPXrw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L1%20Image%201.png?raw=true)

Why MANTRA? Why Real-World Assets? Let's talk about a market that's not just big, it's colossal! The global real-world asset (RWA) market is estimated to be worth a staggering $16 trillion by 2030. MANTRA Chain is your key to unlocking this immense potential, allowing you to compliantly tokenize and trade these assets on the blockchain with unprecedented ease and flexibility.

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

## Course Overview

Here's what you can expect from this course:

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcnQ1qRWjg63ONa-1A-26DusqrSogrE6zLKC5uKxutUBzXGOwNogpbOXLqdYMlFXSas-3sOqWf7-NVwM5Flnpk3SL0dUTkuVUQesV-9Sqp7DLGlRga6T5y0fgNVq8FNNz8D9RXo4BjppsU9xTMZK5g85Fjp?key=5nux_2-mkDEv0d6cByPXrw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L1%20Image%202.png?raw=true)

1. **Cosmic Beginnings:** An Introduction to the Cosmos Ecosystem
2. **RWA-lly Important Stuff**: The ABCs of Real-world Assets(RWA), Liquidity, Regulations, and Compliance
3. **MANTRA Chain Unchained**: Envisioning the Future with MANTRA’s Vision and Mission
4. **MANTRA’s Magic: Building Blocks for Innovation** - Explore the unique advantages and practical applications of the MANTRA Chain
5. **MANTRA’s Architecture**: Unpacking the Lego set behind MANTRA Chain’s Ecosystem!

## Who exactly should take this course?

The MANTRA Chain masterclass is your gateway to the exciting world of tokenized real-world assets. Whether you're a developer, tech enthusiast, or financial professional, this course will equip you with the knowledge and skills to navigate this new frontier. If you're ready to explore the limitless possibilities of blockchain technology and real-world assets, this course is for you!

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

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

1. Understanding of the Cosmos Ecosystem
2. Understanding of RWAs and the need for liquidity in digital assets
3. What is MANTRA Chain, its vision, and mission
4. Deep understanding of the evolution and use cases of MANTRA Chain
5. Understanding of MANTRA Chain architecture

## Proof of completion

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

![https://lh7-us.googleusercontent.com/docsz/AD_4nXf8-8hO2RylDw6wtEWtJoJG1PcNNyPHHP0xfO97bW3UTIQT8WAXZnBrXmj5Dju56kvoWn-jwwmy9CVOuXZZrak15UqmatBeCywWsZ9_PQQxQ5oX_lwJw1OMmqdjFfpqkRd1xOrTZTtBF1dANCxwQLO9oc1H?key=5nux_2-mkDEv0d6cByPXrw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L1%20Image%203.gif?raw=true)

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

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


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

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/1.%20Introduction%20to%20Cosmos%20Ecosystem%20%26%20MANTRA%20Chain/Lesson%201%20-%20What%20are%20we%20learning%20today%3F.md

What Are We Learning Today?

# Introduction to the Cosmos Ecosystem

Hey there developers!! This is it, we are about to step into the future of onchain finance with MANTRA Chain. We are super excited and know that you are too. Just imagine a digital world where you can own a piece of a bustling city skyline, a masterpiece from a renowned artist, or even a share of a company that's changing the world – all from the comfort of your digital wallet.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXey7bf1I_o0YKJYD4T8IQDRjL7DbiAzT04nTvgArf0NDB3xYIqhVmZ0gD33_zsQzOojxozNJrMJMx0rvAIV1u2vIDsNWZkYjUWxBgIQG91lcpqaVA5UE5VfqiGQS-YCq3geXqlQsDdf5b65CWprJUYfk_qp?key=NK29GL8SzocyHEZpOko61Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L2%20Image%201.png?raw=true)

Now, imagine all of this happening while also following the rules and regulations you're used to in the real world. This isn't just a dream; it's the exciting reality that MANTRA Chain is building. It is a revolutionary platform designed to bridge the gap between traditional finance and the world of blockchain, making it possible to own and trade regulated real-world assets (RWAs) like stocks, bonds, or real estate in a secure, transparent, and compliant way.

But MANTRA Chain isn't just any blockchain; it's part of a larger, innovative ecosystem called Cosmos. So, before we dive into MANTRA Chain, we need to lay the groundwork by understanding the incredible Cosmos ecosystem that MANTRA calls home.

## What is Cosmos Ecosystem?

Okay, so what exactly is Cosmos? It's not a single blockchain, but rather a vast network of over 50 independent blockchains and 240+ applications, all working together to create a more decentralized and interconnected internet. It is often called a "Layer 0" blockchain because it provides the essential tools and infrastructure for other blockchains to be built on top of it.

But what does that mean? Well, think of it this way: Cosmos is like the internet but for blockchains! This network is designed to address some of the biggest challenges facing the blockchain industry, like scalability and interoperability.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcNJy9hVkYOWVnxivz7vXKDeaaJSe_o3mSMiKu6Aw7-T5TUtHXmLKPzqg2lRQejkOcj80wIhPugJzEdYiA43Z_v9wnMYE_PMTV523TsZCxT2906CW_GBSYpX9pdVe5eYvIe5efHudCNCnVxLw9dIF2I-F3u?key=NK29GL8SzocyHEZpOko61Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L2%20Image%202.gif?raw=true)

Imagine you have a bunch of different apps on your phone. Each app has its unique purpose – maybe one is for messaging, another for social media, and another for playing games. They all work independently, but sometimes they need to share information with each other. For example, you might want to share a photo from your camera app with your social media app.

Cosmos is similar, but instead of apps, we have blockchains. Each blockchain has its strengths and weaknesses, which can be used for different things. But thanks to Cosmos, these blockchains can now easily communicate and share information with each other, just like the apps on your phone.

This easy communication between blockchains is called **interoperability,** and it's a game-changer. It's like having a universal translator that allows different blockchain "languages" to understand each other. This creates what's often called the **Internet of Blockchains** – a vast network of interconnected blockchains working together, each specializing in its strengths.

## Key Components of Cosmos: The Building Blocks of Interoperability
Cosmos achieves the impressive interoperability through a set of powerful tools:
![https://lh7-us.googleusercontent.com/docsz/AD_4nXdETw5NK6Rb4lboKtsU6_LsVmKYcqKqLziF-3Os_d_Gf5UwjDtVYuhQd_yIAdih_fwHQrRFc0PnBWyMZiUHgXWhLloOooRJ7DcAUmuop3zMrinMgg7yXzT-7Y6K5leSv7Hk_0DY51rzEA9NRtOs6-T87cFm?key=NK29GL8SzocyHEZpOko61Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L2%20Image%203.png?raw=true)



- **CometBFT (formerly Tendermint Consensus):**
    - This is the heart of Cosmos, providing a secure and efficient consensus engine. It ensures that all the blockchains in the network agree on the order of transactions and the system's current state. Think of it as the traffic cop directing the flow of information across the network.
    - CometBFT utilizes a Byzantine Fault Tolerant (BFT) consensus algorithm, meaning it can tolerate up to 1/3 of the validators acting maliciously or failing. This is achieved through a round-based voting process where validators propose, prevote, and pre-commit on blocks. This ensures that the network can continue to function even if some nodes are compromised or offline. The algorithm is designed to be fast and efficient, allowing for quick block times and high throughput.

        ![https://lh7-us.googleusercontent.com/docsz/AD_4nXcWXvprjcq0oLsA84K0gzzKoT-v5DmEfsVup2wBRqt2XypATP1Sk5KrCpSgFrZ2JQ74sU1UC09LE1RnkQsQK45Oj07REClMBx0mbvGV29sEJZKsU1uPUAxnSSGxBOUUNRfKRLa_4c-N_Y5wisy2p2izTW4e?key=NK29GL8SzocyHEZpOko61Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L2%20Image%204.png?raw=true)

- **Inter-Blockchain Communication Protocol (IBC):**
    - This is the magic that allows different blockchains to communicate with each other. It's like a universal translator that allows different blockchains to send and receive tokens, data, and other types of messages.
    - Technically speaking, IBC is a set of standardized protocols that define how blockchains can establish connections, open channels for communication, and verify the authenticity of messages. It relies on a system of light clients and relayers to securely transmit data packets between chains. Light clients are minimal versions of blockchain software that can verify the state of another blockchain without needing to download the entire blockchain history. Relayers are responsible for forwarding messages between chains, ensuring that they are delivered reliably and in order.

        ![https://lh7-us.googleusercontent.com/docsz/AD_4nXcR39GpWsQ0_7xHyLsCkHHVNjeVqjlNIVuMn7Ae6d7fJ_EyJOUXgYRT2nOR2CLOXzpB4kscodIR_VPCpf3ArCjizdBvXI9xSoCXem0kG4Mh_w00BkN7GNFsSaspb89NGOW1UJvdAtt2p2nWoBLVBAVq7QcU?key=NK29GL8SzocyHEZpOko61Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L2%20Image%205.gif?raw=true)

- **Cosmos SDK (Software Development Kit):** This is a handy toolkit that simplifies the process of building new blockchains on the Cosmos network. It's like a set of pre-built modules that developers can use to quickly and easily create custom blockchains with specific features and functionalities.
- **CosmWasm:** This is a smart contract platform that allows developers to write smart contracts in various programming languages (like Rust and Go) and deploy them on the Cosmos network. This opens up a whole new world of possibilities for building decentralized applications (dApps) that can run on multiple blockchains.

Together, these components create a powerful and flexible framework for building interconnected blockchains and dApps. They allow developers to choose the best tools and technologies for their specific needs, while still being able to interact seamlessly with the broader Cosmos ecosystem.

While the Cosmos ecosystem offers a powerful platform for blockchain innovation, one area where it was initially lacking was a specialized chain designed to handle the complexities of regulated real-world assets (RWAs). This is where MANTRA Chain steps in, filling this crucial gap with its focus on compliance, security, and the tokenization of traditional assets.

## Wrap up

Awesome! We got an introduction to the Cosmos ecosystem. But it is not enough to build the base to learn MANTRA Chain. In the next lesson, we will learn more about real-world assets and the need for regulatory compliance in the digital asset space. Understanding these topics is very crucial to understanding MANTRA Chain and its vision.

We are super pumped and very excited to learn about how MANTRA Chain is revolutionizing the way we interact with real-world assets, unlocking new possibilities for investment, and creating a bridge between traditional finance and the decentralized future. Get ready to dive deeper into this exciting blockchain in our next lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/1.%20Introduction%20to%20Cosmos%20Ecosystem%20%26%20MANTRA%20Chain/Lesson%202%20-%20Introduction%20to%20the%20Cosmos%20Ecosystem.md

Introduction to the Cosmos Ecosystem

# What are RWAs & Need for Regulatory Compliance

Welcome back, learners! In our last lesson, we explored the exciting Cosmos ecosystem and its unique approach to blockchain interoperability. Now, we know you're eager to dive into MANTRA Chain, but before we do, let's build a strong foundation for understanding this innovative blockchain.

In this lesson, we will learn about What are RWAs? The need for liquidity in RWAs and the need for regulatory compliance in the digital asset space. By the end of this lesson, you'll have a solid grasp of the key concepts that underpin MANTRA Chain's vision and mission. So, get ready to expand your knowledge and prepare for a deep dive into the exciting world of RWAs!

## What are Real-World Assets?

We have seen the term “real-world assets” a lot since the last lesson, it's high time we actually define RWAs.

Simply put, real-world assets are tangible or intangible things of value that exist in the physical world – not just in the digital realm. They can be anything from physical assets like real estate, gold, cars, art, etc.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXciBF-uEMAovZ66bd16e4V2RBfzfPO30f7_KnHfpYYgiU71A8LKWKGFEy5VDw7OBwpLXoicoCAXtE9cHdMAQ_ybK3v56DP38do02Pry5SChfhRnCVMs5cdU4bn2Ky5S7o_jCf0dCItnp_kgnNFHXwl_H2yg?key=lp5CYlFAkv3ksy3UwU_zKQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L3%20Image%201.png?raw=true)

Think of it this way: if you can touch it, own it, or trade it in the traditional financial world, it's likely a real-world asset.

### What is the role of Blockchain technology in expanding access to RWAs

RWAs have always been a cornerstone of the global economy. They represent real value and offer various investment opportunities. However, investing in RWAs has often been exclusive, and limited to wealthy individuals or institutions.

This is where blockchain technology steps in, offering a potential game-changer. Blockchain can revolutionize the way we interact with RWAs by:

![https://lh7-us.googleusercontent.com/docsz/AD_4nXc0w5Uk9WOdUSIksW4FInP_RlG8PZqF2_QlhfhWwnJAb7ZwZXcCczp1mIm-W3lmxwXiCMfITsPXBaUXZfwkdsuUvY7hQNAzWrfXNVio7LdSaOhr1r9yDr4Zt3UXyhVNk8WVC0Mfs0Y-0p7hYy_xkOTaqppA?key=lp5CYlFAkv3ksy3UwU_zKQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L3%20Image%202.png?raw=true)

- **Tokenization:** Turning RWAs into digital tokens on the blockchain makes them easier to buy, sell, and trade. This unlocks liquidity and opens up investment opportunities to a broader audience.
- **Fractional Ownership:** Blockchain enables fractional ownership of RWAs, allowing investors to own a small portion of an asset that would otherwise be too expensive to purchase outright.
- **Transparency and Security:** Blockchain's immutable ledger ensures transparency and security in RWA transactions, reducing fraud and increasing trust.
- **Global Accessibility:** Blockchain removes geographical barriers, allowing investors from around the world to access and invest in RWAs.

In the next section, we'll delve deeper into why RWAs need liquidity and how blockchain can address this need. So, buckle up as we explore the exciting potential of RWAs in the world of blockchain!

## The Need for Liquidity in RWAs

While RWAs offer promising investment opportunities, they come with a significant challenge: liquidity.

**What is Liquidity?**

Liquidity refers to how easily an asset can be bought or sold without affecting its price. Cash is the most liquid asset, as it can be easily exchanged for goods and services. However, RWAs like real estate or fine art are much less liquid. In the traditional market, it can take weeks or even months to find a buyer or seller, and the price you get might not always be fair. The process is far more opaque and restrictive.

**Challenges with Traditional RWA Investments:**

![https://lh7-us.googleusercontent.com/docsz/AD_4nXc3g82lnHj9IlbiA5wx2idMAQHx8etvzwshgM5hF4qbZy8HXdogOrPA2Smz9_rQGvCdy6n4ly7ntG2eb4F1Sp7fdbYjnvRqUVhcf4GI3loHTGwus4XoMN4CGMgmd8WlmmlOAwoF4zdpLeTU1HCsyNxI2tA?key=lp5CYlFAkv3ksy3UwU_zKQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L3%20Image%203.png?raw=true)

1. **Illiquidity:** As mentioned above, RWAs are not easily converted into cash. This means your investment is locked up, and you might not be able to access your money quickly if needed.
2. **High Barriers to Entry:** Many RWAs require significant capital to invest, making them inaccessible to most people. For example, buying a property or investing in a large-scale infrastructure project requires a substantial amount of money upfront.
3. **Lack of Transparency:** Traditional RWA markets often lack transparency. Information about ownership, valuations, and transactions can be difficult to obtain, making it hard for investors to make informed decisions.

**How Tokenization Unlocks Liquidity:**

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcAMFHJJQK7-G_gZUqGKy-KJxwiV-JZPLIi8s2hoCOYXNL061lme6ZzNuRn8pFJZjh2fI51xnrSoc6YdaaKliadgrWgv-xQfFlyWoqzSO2C4Hs4c9NI2GmDivKitSens-24DIWumL9xGgdoENkMterDa8o?key=lp5CYlFAkv3ksy3UwU_zKQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L3%20Image%204.png?raw=true)

Tokenization is the process of converting RWAs into digital tokens on the blockchain. These tokens represent fractional ownership of the underlying asset. For example, a real estate property worth \$1 million could be divided into 1 million tokens, each worth $1. This makes investing in RWAs more accessible and affordable for everyone.

But tokenization does more than just make RWAs affordable. It also significantly improves their liquidity. In theory, tokenized RWAs could be tradeable on digital exchanges 24/7, just like cryptocurrencies. This means you can buy or sell your share of a real estate property, a piece of art, or even a racehorse with a few clicks, at any time.

By increasing liquidity, tokenization opens up new opportunities for investors and asset owners. It allows investors to diversify their portfolios and access asset classes that were previously out of reach. For asset owners, it provides a new way to raise capital and unlock the value of their assets.

![Tokenization-V2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L3%20Image%205.png?raw=true)

As we've seen, tokenization has the potential to unlock immense value in the world of RWAs. But for this potential to be fully realized, it's crucial to address another key factor: regulatory compliance.

Let's delve into why navigating the regulatory landscape is so important for the future of RWAs in the digital asset space.

## The Need for Regulatory Compliance in the Digital Asset Space

As the world of digital assets continues to evolve, so does the regulatory landscape surrounding it. Governments and financial authorities worldwide are grappling with how to oversee this rapidly growing space. Some countries are embracing blockchain and crypto, while others are taking a more cautious approach.

**Why Compliance Matters:**

Regardless of the specific regulations in each jurisdiction, one thing is clear: compliance is crucial for the long-term success and adoption of digital assets. Here's why:

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdZrEcNAj6lqD5dgOD3jWPwqkVjyDif4Zjj_x2x7D1jQ0IklEFcT7MdR-P37eVg1889rb9p2RFyoEvAMOZyQbve9v9yuF4zWmdI1IA6JRW8aCS0bNIn5QrjUmXC_6QH66fQY_hIh7pGEn6UyDDyLrlwtIEP?key=lp5CYlFAkv3ksy3UwU_zKQ](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L3%20Image%206.png?raw=true)

1. **Building Trust:** Clear and consistent regulations create a framework for trust. When investors and institutions know that there are rules in place to protect them, they are more likely to participate in the market.
2. **Protecting Consumers:** Regulations help protect consumers from fraud, scams, and market manipulation. By setting standards for transparency, security, and fair practices, regulators can ensure that investors are not taken advantage of.
3. **Preventing Illicit Activities:** Unfortunately, the anonymity and borderless nature of cryptocurrencies have sometimes attracted bad actors who use them for illegal activities. Robust regulations help prevent and deter such activities, making the digital asset space safer for everyone.
4. **Fostering Innovation:** While it might seem counterintuitive, appropriate regulation can actually foster innovation. By providing a clear legal framework, regulators create a stable environment where businesses can develop new products and services with confidence. This can lead to the creation of innovative financial solutions that benefit consumers and businesses alike.
5. **Mainstream Adoption:** For digital assets to truly go mainstream, they need to be embraced by traditional financial institutions. These institutions are unlikely to get involved unless there are clear regulations in place. Compliance is therefore a key stepping stone to wider adoption.

## Wrap up

We've just scratched the surface of the exciting world of real-world assets and how they're shaking up the blockchain space. We've seen how these tangible assets can be transformed into digital tokens, opening doors to new investment opportunities and increased liquidity. And we've touched upon the importance of navigating the regulatory landscape to ensure a secure and trustworthy environment for all.

But hold on tight because the real adventure is just beginning! In our next lesson, get ready to discover how MANTRA is revolutionizing the way we think about investments, bridging the gap between traditional finance and the decentralized future. So, get your explorer hats on, because we're about to embark on an exciting journey into the heart of MANTRA Chain!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/1.%20Introduction%20to%20Cosmos%20Ecosystem%20%26%20MANTRA%20Chain/Lesson%203%20-%20What%20are%20RWAs%20%26%20Need%20for%20Regulatory%20Compliance.md

What are RWAs & Need for Regulatory Compliance

# What is MANTRA Chain? It's Vision and Mission

Welcome back, fellow developers! 🎉

We are on an exhilarating journey to explore the groundbreaking MANTRA Chain. So far, we’ve taken the first two steps (give yourself a pat on the back—those initial strides are always the toughest!). We’ve delved into the Cosmos ecosystem and dived deep into the fascinating world of Real-World Assets (RWAs). But now, it’s time for our next adventure: understanding MANTRA Chain itself.

In this lesson, we’ll dive deep into MANTRA Chain, discover its inspiring vision and mission, and explore why it’s set to create ripples in the decentralized finance universe. So fasten your seatbelts, my fellow crypto enthusiasts, because we’re about to dive headfirst into this revolutionary blockchain! 🚀💡

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcbVB60w2ukL8VHIuUbIEK9IY2sOIzEc_fZWAdUUCInyIjuzgTkKV5qE8Ga6hLhrmOkqU-vqDJLI3goaiCyiaExf_KruCmAnCsaVBHtH9JVxE_D_P6NCW1CeBGMKZiO8e99cUQTv4cJHJDcnMCnJZHNQyw?key=JTIHcQ6qj0Iy8WcNv-wT7Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L4%20Image%201.png?raw=true)

## What is MANTRA Chain?

MANTRA Chain is a cutting-edge blockchain network, designed from the ground up to bring real-world assets (RWAs) onto the blockchain, making them easily accessible and tradable.

But here’s the kicker – it’s all done by the book, with dApps built for RWAs following the same rules as the regular financial world.

It's built with regulatory compliance in mind, so you can be confident that your tokenized assets adhere to the same rigorous standards as their traditional counterparts. It's all about keeping things legit and above board! This means you can explore the exciting world of tokenized assets with the confidence and security you're used to.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdoYFN1c6HXURhV0x4jLBRk1GTRbSJ2OVtkhqD_3b9qpPjluCesW7-1mi5fiyqrcE53EbSvp-OdTnNpQrybjvUoWPRfnoAAnLdQU5FChQWuZAyH6ltp9UVBkRMlNMQuBdjOo8sfr2rQfOI5qkTnPrgJTOuZ?key=JTIHcQ6qj0Iy8WcNv-wT7Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L4%20Image%202.png?raw=true)

So, when we say that “MANTRA is a security-first RWA Layer 1 Blockchain bringing the world’s financial system onchain”. What it really means is that MANTRA Chain is like the first layer of a new internet for trading real stuff, and it’s all set up to play nice with the rules. And yeah, those last couple of chapters you read? They totally set you up to understand this!"

## Permissionless Layer 1 blockchain designed for Permissioned applications

MANTRA Chain is all about staying ahead of the game when it comes to rules and regulations. It’s believed that public blockchains will be the settlement layer for tokenized RWAs, and that the application layer is where regulators will focus. That’s why MANTRA is an open-invite blockchain (that’s what ‘permissionless’ means) that’s also totally prepped to handle dApps that need authorized access (permissioned).

Think of it like a public park that's also designed for private events. The park is open to everyone (permissionless), but there are certain areas that can be reserved for specific groups or activities (permissioned).

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfKPCono2Hxu6WSrO_bcJBD8-L07r_gQN9gZAg-5SvnzgBLZo0WUgYu6slHelXMJx_eL9SR42X-lQ9rJJJI7mSpXU4XebABoU8wOwYSRp43_xgwc_v9mfHz5MVofsvzSQSOEppJuKCOUpxuaBnSQug5Ptqe?key=JTIHcQ6qj0Iy8WcNv-wT7Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L4%20Image%203.png?raw=true)

In the same way, MANTRA Chain is a blockchain that anyone can join and use. However, it also allows for the creation of special, regulated sections where only authorized participants can access and trade specific assets. This is ideal for tokenizing regulated real-world assets like stocks or bonds, which require stricter controls to comply with financial laws.

So, MANTRA offers the best of both worlds: the openness, composability and flexibility of a public blockchain with the security and compliance features needed for traditional financial assets.

To empower developers in creating compliant applications (applications that follow the rules and regulations in their specific jurisdiction), MANTRA Chain provides a comprehensive environment designed specifically for this purpose. This environment equips developers with the necessary components to build regulated, compliant, and permissioned applications on top of MANTRA's high-performance, scalable blockchain architecture.

This allows for the creation of Web3 applications that not only leverage the benefits of decentralization but also adhere to the necessary regulatory frameworks. This unique combination of permissionless infrastructure and permissioned application development makes MANTRA Chain a powerful platform for the future of regulated digital assets, while also providing an attractive space for developers seeking to build innovative, decentralized applications without regulatory constraints.

## Why MANTRA Chain matter?

So, you know how the Cosmos ecosystem is huge with 50+ blockchains. Well, there’s been a piece missing – a blockchain that’s all about following the rules, especially for assets that exist in the real world and those that are digital tokens. That’s where MANTRA Chain comes in. It’s like the missing piece that’s all about being on the right side of the law.

Here’s the scoop on why MANTRA Chain is pretty awesome:

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcLsDYDCjWm8b0WIAxUWthIVjx3KHccJDGrPzRZrhSZg99dRz1Vg-HOFDLlPSLKOyRG0d4l4mqbbWzAZBVv_G3Lq51I062j0OMXfPWrc8XSwyuJPM8Us3jNYZ-gT1Bst2aBiPdD4GG0tiFYrbgl8PthHKQ?key=JTIHcQ6qj0Iy8WcNv-wT7Q](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L4%20Image%204.png?raw=true)

- **Playing by the Rules:** MANTRA Chain is providing all the necessary tools to build regulatory-compliant dApps, ensuring that when you engage with the permissioned blockchain segment, you can be confident in the high standard of compliance it offers.
- **Attracting Diverse Users:** By offering a permissioned environment, MANTRA Chain is rolling out the red carpet for all kinds of investors, including the big fish in the pond who like everything neat and tidy, legally speaking.
- **Fostering Innovation:** MANTRA Chain’s permissioned environment is like a playground for smart folks who want to create cool financial apps. It follows all the safety rules, while keeping the spirit of freedom and innovation alive.
- **Global Reach:** With its eyes on the prize of being aligned with authorities all over the planet, MANTRA Chain is on its way to becoming a worldwide hotspot for investing in tokenized goodies.

With its unique combination of regulatory compliance, technological innovation, and global vision, MANTRA Chain is poised to lead the way in the new era of decentralized finance.

## What is the vision and mission of MANTRA Chain?

Imagine MANTRA Chain as a visionary architect in the finance world. It’s not just another block in the blockchain neighborhood. It’s got a grand plan to change how we deal with money, making sure that stuff like houses, gold, or even paintings can move into the blockchain neighborhood smoothly.

It’s all about connecting the old-school money ways (that’s TradFi) with the cool, new decentralized finance scene (yep, that’s DeFi), making it easier for everyone to get in on different kinds of investments and making those investments flow better.

To achieve this vision, MANTRA Chain has built a robust and scalable blockchain architecture on the Cosmos SDK, designed to handle the complexity of real-world asset tokenization with security, transparency, and efficiency.

MANTRA Chain offers a robust environment and infrastructure for developing products in both permissioned and permissionless manners. For the permissioned sector, MANTRA Chain is dedicated to create infrastructure that is adhering to regulatory compliance and providing essential tools for building secure, compliant applications. Meanwhile, for the permissionless sector, MANTRA Chain invites everyone to innovate and experiment on an open and accessible platform.

And here’s the heart of it all: MANTRA’s mission is to make the financial world a place where anyone can participate. They’re building a system that’s open and fair, giving people everywhere the chance to grow their wealth with all sorts of assets. That’s the spirit driving MANTRA Chain – to create a financial playground that’s inclusive, innovative, and full of possibilities for everyone.

By addressing the challenges of liquidity, accessibility, and regulatory compliance, MANTRA Chain is paving the way for a new era of financial innovation and inclusion.

## Wrap up

Did we get you excited about MANTRA Chain? Are you ready to have your mind expanded (even more😁)? You should be! MANTRA Chain isn’t just opening doors; it’s knocking down walls to a universe brimming with opportunities. We’re on the edge of our seats, eager to dive into the nuts and bolts of its design and the amazing ways it can be used. These applications are going to be nothing short of mind-bending, showcasing the untapped power of bringing real-world assets into the digital domain. Buckle up, because our next lesson is going to take you on an exhilarating journey through the evolution of MANTRA Chain!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/1.%20Introduction%20to%20Cosmos%20Ecosystem%20%26%20MANTRA%20Chain/Lesson%204%20-%20What%20is%20MANTRA%20Chain%20It's%20Vision%20and%20Misson.md

What is MANTRA Chain It's Vision and Mission

# MANTRA’s Evolution and Ecosystem

Our journey into the world of MANTRA Chain continues! We've already explored the Cosmos ecosystem and the exciting potential of Real-World Assets (RWAs). Now, get ready to uncover the fascinating story of how MANTRA Chain itself came to be.

Think of it like a superhero origin story, but instead of superpowers, we've got blockchain technology and a mission to revolutionize finance. Early on, MANTRA recognized the importance of the Cosmos ecosystem, seeing its potential to create a truly interconnected blockchain universe. Since 2020, MANTRA has been actively involved in the Cosmos community, collaborating with developers and contributing to the growth of the interoperable blockchain network.

This early engagement laid the foundation for MANTRA Chain's eventual migration to the Cosmos ecosystem, showcasing its commitment to innovation and adaptability. From its starting days on Ethereum to its groundbreaking leap into the Cosmos, MANTRA Chain's evolution is a testament to its unwavering pursuit of creating a more accessible and inclusive financial system.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcz9YjoiXkBICYKcsx1Kuq8cUCQRaE3unHfta1WiyjkN5oBLDpEUkHPPAzSnr4EnSlaZ13QEYpAh3mWNbJxP_22AY0kTZHkcVMAZ5IhR8vkbeXWvNCG71F3k3agR4oseAPeQWcbLutwzPnSPqwegf8oMrdV?key=YWyODTc4sc5Fs1B1XtR_Mw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L5%20Image%201.png?raw=true)

In this chapter, we'll dive into the key milestones that shaped MANTRA Chain into the powerhouse platform it is today. Get ready to discover how this project is not just tokenizing assets, but also building a bridge between the traditional and decentralized worlds of finance. So, buckle up and get ready for a journey through the evolution of MANTRA Chain – it's going to be epic!

## MANTRA Finance: A Compliant Bridge Between TradFi and DeFi

The MANTRA Chain saga began on Ethereum, the blockchain that birthed the DeFi movement. Out of that movement, MANTRA Finance emerged driven by a mission to bridge the divide between traditional finance (TradFi) and decentralized finance (DeFi).

Recognizing the key challenges that have hindered wider DeFi / onchain adoption, such as the lack of robust KYC/AML checks, effective monitoring, and user-friendly interfaces, MANTRA Finance set out to provide a secure, transparent, and compliant platform that would attract both institutional and retail investors to the DeFi space.

By combining the benefits of self-custody with the security and regulatory oversight of centralized exchanges, MANTRA Finance offers a "best of both worlds" approach. The platform initially launched on Ethereum, BNB Chain, and Polygon, providing a diverse range of yield-bearing DeFi products designed to deliver a safe and compliant environment for its customers.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcaedPDn6jT9unOC4dcgnJhq08TkqRjw0aZankVGZFv7OjMJv-4C3iw4LwtnoP0RUZKgmg_diDN25sIbgbPw6siTai949Fouy_Uu0OXBdwZeyhG1NqIMDzXlDBhREFsqHqqIg5U1YKsh5DuBAEzx_taXIio?key=YWyODTc4sc5Fs1B1XtR_Mw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L5%20Image%202.png?raw=true)

At the core of MANTRA Finance's unique value proposition is its ability to offer the transparency, efficiency, and speed of DeFi, while maintaining regulatory focus and a fully compliant platform.

Key elements of this value proposition include:

- **Transparency:** All transactions are publicly viewable on the blockchain, ensuring accountability and trust.
- **Efficiency & Speed:** Multi-chain interoperability allows for high-speed, low-cost transactions across different networks.
- **Segregated Accounts:** Client assets are safeguarded from misuse through segregated accounts, protecting users and their investments.
- **Regulatory Focus:** MANTRA Finance collaborates closely with international regulators to ensure products and services meet all applicable requirements, prioritizing user protection and asset security.
- **Compliant Platform:** KYC onboarding and ongoing AML monitoring provide a secure and compliant environment for all users.

By bridging the gap between TradFi and DeFi, MANTRA Finance is empowering investors to experience the benefits of decentralized finance in a secure and compliant manner, ultimately driving broader adoption and ushering in a more inclusive and transparent financial ecosystem.

## MANTRA's Cosmos Leap: A Strategic Move for Interoperability and Scalability

MANTRA Finance's vision was ambitious, but the limitations of the Ethereum network, such as high gas fees and scalability bottlenecks, posed significant challenges. To overcome these obstacles and fully realize their vision, MANTRA actively sought out a more suitable solution that could meet the specific needs of MANTRA’s platform. The Cosmos ecosystem, with its focus on interoperability, scalability, and customizability, proved to be a good fit for MANTRA's ambitious goals.

The Inter-Blockchain Communication (IBC) protocol, a core feature of Cosmos, opened the door to seamless asset transfer across different chains, presenting a new frontier for RWA tokenization.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXd1WKKOe8Tm-nEREk2Gn5Gotaeajkt-DcOK-GDogAAkWzYH8ow4wYQFURZm9f9D97At6TeGq2IV11Y3MO5fPM_RyEtJgbWCnILpuoQcI7538DBzyUElAVmEOBRLUQhBgUXj7rrsQWPiPXO7lgkzWCN8U7hV?key=YWyODTc4sc5Fs1B1XtR_Mw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L5%20Image%203.png?raw=true)

MANTRA developed a dedicated blockchain called MANTRA Chain. This custom-built chain leverages the Tendermint consensus mechanism, a Byzantine Fault Tolerant (BFT) engine renowned for its speed, security, and efficiency. Tendermint's Proof-of-Stake consensus offers fast transaction finality, enhanced security against attacks, and the capacity to handle high volumes of transactions.

This robust infrastructure, combined with the interoperability of the Cosmos ecosystem, provided the ideal foundation for MANTRA's RWA ecosystem. It ensured swift and secure asset transfers while supporting a wide range of complex financial products and services. By harnessing the power of Cosmos and Tendermint, MANTRA was well-positioned to drive innovation and overcome the limitations that had previously hindered its progress, opening up a world of new possibilities for the tokenization and democratization of real-world assets.

## Hongbai Testnet: A Glimpse into the Tokenized Future

The Hongbai Testnet marked a pivotal moment in MANTRA Chain's journey within the Cosmos ecosystem. Far more than a simple testing phase, it also serves as 1:1 copy of the real environment where the chain's core functionalities, robustness and efficiency can be tested.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXdKjh9ZS8Zv-btvsGXXqS0YLyVPSvPU7p9FBk0jCrfn0Z0GIRJDVCdLTxM1kgIfJaODrHsdrA99H7UV8O0WeHmsMTSWcPGcf580-sQYTvtvIeGHqTOmCJZ8KSnaJynpCELNu5Cpg_b0m2dZxJ0_LxQXHorz?key=YWyODTc4sc5Fs1B1XtR_Mw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L5%20Image%204.gif?raw=true)

A key focus of the Hongbai Testnet is to thoroughly test MANTRA Chain's integration with the Inter-Blockchain Communication (IBC) protocol. This groundbreaking technology enables seamless communication and asset transfer between different blockchains within the Cosmos network. By rigorously testing this integration, MANTRA Chain developers ensured that their platform would be ready to participate in the broader Cosmos ecosystem from day one.

The Hongbai Testnet was also instrumental in stress-testing the chain's performance under real-world conditions. Developers simulated various scenarios, including high transaction volumes and network congestion, to ensure that MANTRA Chain could handle the demands of a thriving ecosystem.

But Hongbai was not just about technical validation; it was a glimpse into the future of interoperability. Users could experience firsthand how MANTRA Chain would interact with other Cosmos-based blockchains, seamlessly exchanging tokenized assets across different networks. This showcased the potential for a truly interconnected ecosystem where assets can flow freely and securely, opening up new possibilities for decentralized finance (DeFi) and beyond.

In essence, the Hongbai Testnet was a crucial proving ground for MANTRA Chain's technology and vision. It allowed developers to identify and address potential issues, optimize performance, and ensure a smooth and secure mainnet launch. But more importantly, it provided a tantalizing preview of the interoperable future that MANTRA Chain is building within the Cosmos ecosystem.

## $OM Token: Evolving with MANTRA Chain's Ambitions

$OM, the beating heart of the MANTRA ecosystem, has undergone a remarkable transformation, mirroring the platform's evolution from DeFi on Ethereum, BNB Chain, and Polygon, to the Cosmos-powered MANTRA Chain we know today.

![Om token](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L5%20Image%205.png?raw=true)

**A Token's Transformation into a Coin**

Originally, $OM was a utility token, primarily used for staking, rewards, and soft governance within the MANTRA ecosystem. It granted holders a voice in the ecosystem's direction, but its role was primarily tied to the DeFi applications on Ethereum, BNB Chain, and Polygon.

However, with the transition to the Cosmos-powered MANTRA Chain, $OM is set to become a full-fledged coin. This means it will take on new responsibilities, including:

- **Securing the Network:** \$OM holders will be able to stake their coins to help secure the MANTRA Chain, ensuring its integrity and decentralization. This process, called staking, involves locking up $OM tokens as collateral to validate transactions and earn rewards.
- **Onchain Governance:** $OM holders will gain the power to directly vote on proposals and decisions that shape the future of the MANTRA Chain, giving them a stronger voice in the platform's governance.
- **Paying for Gas Fees:** $OM will be used to pay for transaction fees on the MANTRA Chain, making it an essential component of the network's economy.

**Listing on Top-Tier Exchanges**

Despite its ongoing evolution, $OM has already garnered significant attention in the crypto world. It's currently listed on top-tier exchanges like Binance, making it easily accessible to traders and investors worldwide.

**The Future of** $**OM**

As MANTRA Chain continues to grow and expand, so too will the utility and value of $OM. It's poised to become a key player in the Cosmos ecosystem, powering a wide range of decentralized applications and financial services.

Whether you're a long-time $OM holder or new to the MANTRA ecosystem, the transition to a full-fledged coin is a significant milestone. It's a testament to MANTRA's commitment to decentralization, security, and community-driven governance. With OM at its core, MANTRA Chain is well-positioned to unlock the full potential of real-world assets on the blockchain.

## Wrap up

MANTRA Chain's journey from Ethereum to Cosmos has been nothing short of extraordinary! We've explored its mission to reshape finance and its innovative technology. But hold on tight, the adventure continues! In our next lesson, we'll delve into the technological marvel that powers MANTRA Chain, uncovering the secrets behind its security, scalability, and interoperability. Get ready to experience the engine that's propelling MANTRA Chain towards a brighter financial future.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/2.%20Exploring%20MANTRA%E2%80%99s%20Ecosystem/Lesson%205%20-%20MANTRA%E2%80%99s%20Evolution%20and%20Ecosystem.md

MANTRA’s Evolution and Ecosystem

# Why build on MANTRA Chain and Use cases

Alright, MANTRA explorers, it's time to take your understanding to the next level! We've delved into the inner workings of MANTRA Chain, its vision, and the revolutionary world of real-world assets (RWAs). Now, let's get down to business and explore the tangible benefits and exciting possibilities that MANTRA Chain unlocks.

In this lesson, we'll uncover what makes MANTRA Chain such an attractive platform for builders and users alike. We'll delve into its unique features, including its community-driven governance model and seamless interoperability with other blockchains. And, of course, we'll showcase some real-world use cases that demonstrate the immense potential of MANTRA Chain to transform industries and create new opportunities.

Get ready to witness how MANTRA Chain is reshaping the financial landscape and empowering individuals and businesses to embrace the future of decentralized finance.

## Why Build on MANTRA Chain?

![https://lh7-us.googleusercontent.com/docsz/AD_4nXc3TzK0kUppJprdcYBgLRjrWjFtBuLa7Esud_Vm3chWYgcXezZGUeUWeje1HYrWJt7EcdtJEh9kMcQpsLFyRHLDI3DoQYoTP5qdkivc9b3MNIpJ4anR9J_QG5UKgvgROhCvdIgdqM2UskIyRa0jQLYbwkDU?key=3AecdSTL2OCLThArOtizTg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L6%20Image%201.png?raw=true)

Okay, builders, let's get real. Why should you choose MANTRA Chain as your launchpad for your next decentralized application (dApp)? It's simple: MANTRA Chain offers a unique combination of features that make it the ideal platform for bringing real-world assets into the digital age.

- **Regulatory-Ready Infrastructure:** MANTRA Chain is designed with compliance at its core. Leverage its robust framework for secure asset tokenization and other built-in tools to effortlessly meet regulatory requirements and instill trust in your dApps.
- **Seamless Cross-Chain Interoperability:** Built on the Cosmos SDK and leveraging the Inter-Blockchain Communication (IBC) protocol, MANTRA Chain offers seamless interoperability with other Cosmos-based chains. This opens up a world of possibilities for creating cross-chain applications and tapping into diverse liquidity pools.
- **High-Performance Engine:** Powered by the Tendermint Core's CometBFT consensus engine, MANTRA Chain delivers lightning-fast transaction finality, high throughput, and proven security. Your dApps will run smoothly, even under heavy load.
- **Flexible & Customizable:** The modular architecture of MANTRA Chain allows you to easily integrate custom modules and functionalities, tailoring the blockchain to your specific use case. CosmWasm smart contracts, written in Rust, offer unparalleled flexibility and security for your dApp logic.

But the real magic of MANTRA Chain lies in its ability to transform how we interact with real-world assets. From tokenizing real estate to fractionalizing art, MANTRA Chain is opening up a new world of investment opportunities. So, are you ready to see it in action? Let's dive into features and use cases that demonstrate the practical applications and immense potential of MANTRA Chain in revolutionizing the way we invest and interact with real-world assets.

## Features of MANTRA Chain

![https://lh7-us.googleusercontent.com/docsz/AD_4nXeQ5k6WNhxWeVBo0wJYxz_Ry23gVbA_Ws4wMf3geosXd66Hpghy_rxR7f9sPFDugZCB3VOJc2fqtDIf7fmiwd-YnofxBycRgKv8ZSle1o9GnLkGIq8sP2zkSP1o9foUi7qp6SD9QNVWv_ECSGU9c8HfBmE_?key=3AecdSTL2OCLThArOtizTg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L6%20Image%202.png?raw=true)

MANTRA Chain is packed with innovative features that make it a powerful platform for building the future of decentralized finance. Let's break down some of these features and explore how they contribute to MANTRA Chain's unique value proposition:

- **Decentralized Identity (DID)**: MANTRA Chain's DID system streamlines user onboarding by allowing individuals and businesses to create a secure, verifiable digital identity (DID). This one-time, permissionless process not only simplifies Know Your Customer (KYC) or Know Your Business (KYB) procedures but also offers a user-friendly experience similar to centralized systems. DID will allow all types of users to onboard in a permissionless way through the chain, allowing them to make use of the underlying ecosystem.
- **On and Off-Ramping:** MANTRA Chain makes it easy to bridge the gap between traditional finance and the crypto world. It supports compliant on and off-ramp solutions, allowing you to effortlessly convert your fiat currency (like dollars or euros) into cryptocurrencies and vice versa.
- **IBC Compatibility:** MANTRA Chain's IBC compatibility enables seamless movement of tokens across various Cosmos-based chains. This opens up new possibilities for cross-chain transactions and collaboration.
- **Governance and Continuous Updates:** MANTRA Chain is a community-driven platform where holders of the $OM token can actively participate in shaping the future of the ecosystem. They can propose and vote on changes to the protocol, such as introducing new features, adjusting parameters, or allocating funds from the community treasury.

## MANTRA Chain Use Cases

![https://lh7-us.googleusercontent.com/docsz/AD_4nXevERLVG729zyuhOYFpiPvn919wQZPsNvWbB2y6vS2dq-IQML0VEQFyDFqxGO5ZjccU4tGH_wsP2-AwRgQSL1QN_cBsVOTvsHedqtg4PPGkIy3eLyEE9Z1wIZZixejYiPP4tMxY3_mYgcTwM1KIkxrWtRy0?key=3AecdSTL2OCLThArOtizTg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L6%20Image%203.png?raw=true)

The above-mentioned features pave the way for a wide array of innovative use cases on MANTRA Chain, unlocking the potential of real-world assets in the digital realm. Let's explore some of the most promising applications:

- **Tokenization of Real-World Assets (RWAs):** MANTRA Chain's robust infrastructure allows for the seamless tokenization of various RWAs, such as real estate, fine art, commodities, etc. This opens up new avenues for investment and fractional ownership, making these assets accessible to a broader audience.

- **Prediction Markets:** Imagine a platform like [Polymarket](https://polymarket.com/), but built on a decentralized, transparent blockchain. MANTRA Chain's features enable the creation of prediction markets for real-world events, allowing users to trade on the outcomes of elections, sports events, or economic trends.

- **Perpetual DEXs for RWAs:** MANTRA Chain's IBC compatibility and decentralized infrastructure are perfect for creating perpetual decentralized exchanges (DEXs) for RWAs. This allows for 24/7 trading of tokenized assets with enhanced liquidity and security.

- **Secure Intellectual Property (IP) Management:** By tokenizing intellectual property like patents, trademarks, and copyrights, MANTRA Chain enables secure ownership tracking, easy transfer, and potential licensing or monetization opportunities.

- **Tokenized Debt Securities:** Traditional bonds and other debt instruments can be tokenized on MANTRA Chain, increasing efficiency, transparency, and accessibility for both issuers and investors.

- **Tokenization of Natural Resources:** Bringing natural resources like timber, water rights, or mineral deposits onto the blockchain through tokenization can democratize investment opportunities and promote sustainable management practices.

These are just a few examples of the many ways MANTRA Chain is transforming how we interact with real-world assets. As the ecosystem continues to grow and evolve, we can expect to see even more innovative and groundbreaking applications emerge, redefining the future of finance.

## Wrap Up

These examples are just a taste of what's possible with MANTRA Chain. As the platform continues to evolve, we can expect even more groundbreaking use cases that will reshape how we interact with real-world assets and revolutionize traditional systems. The fusion of blockchain technology, regulatory compliance, and community governance is creating a new paradigm for finance, where the possibilities are truly limitless.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/2.%20Exploring%20MANTRA%E2%80%99s%20Ecosystem/Lesson%206%20-%20Why%20build%20on%20MANTRA%20Chain%20and%20Use%20cases.md

Why build on MANTRA Chain and Use cases

# Understanding MANTRA Chain’s  Architecture

We've embarked on a thrilling exploration of the MANTRA Chain, a vibrant ecosystem where real-world assets transform into digital tokens, and decentralized finance (DeFi) takes on a whole new dimension. But have you ever wondered how this symphony of innovation is orchestrated?

It's time to delve into the architectural marvel that powers MANTRA Chain. Think of it as a backstage pass to the coolest blockchain show in town, where we'll unravel the technological intricacies that make it all possible. Don't worry, we'll keep the jargon to a minimum, making it an engaging and enlightening journey!

## The Blueprint: MANTRA Chain's Architectural Masterpiece

Before we dive into the nitty-gritty, let's get a high-level overview of MANTRA Chain's architecture. Think of it as a blueprint for a futuristic city, where different components work together seamlessly to create a vibrant and thriving ecosystem.

MANTRA Chain is built on a modular design, like a set of LEGO blocks that can be combined in endless ways. This flexibility allows developers to easily add new features and functionalities, making the blockchain adaptable and future-proof.

The architecture is divided into two main parts:

1. **Node Architecture:** This is the basic building block of the blockchain, like the bricks that make up a house. Each node is a mini-computer that tirelessly works to maintain the blockchain's ledger, validate transactions, and participate in consensus.
2. **Network Architecture:** This is the bigger picture, the overall design of the city. It encompasses all the different layers that work together to make the blockchain function.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXcCKSS_O3DHpSo3pAfS5vSPVWxfECT2diwxUPRwvr3VB5fYcVMKXS4G1kdeJX7nSowAINeZc_x2Ty3eQJD_WUmMbrEtfZ0ArzKR58AebMBP_J9xQQVc_M11Nq3Lx6KvypPF1Ob3PwVlK48BX4rsVmMn2Znc?key=1Fe5FFVv1GXQSTaUn6PLrw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L7%20Image%201.png?raw=true)

## MANTRA Chain Node Architecture

Each node in the MANTRA Chain network is like a miniature computer, diligently working to maintain the blockchain's integrity. These nodes are essential for the smooth functioning of the network and play a crucial role in ensuring its security, transparency, and decentralization.

These hardworking nodes have three main components:

1. **Ledger Keeper (State Machine)**: This is the blockchain's memory bank, storing a complete history of every transaction and state change. Every node maintains an identical copy of this ledger, ensuring data integrity and preventing tampering. The state machine is responsible for executing transactions and updating the blockchain's state accordingly. This involves complex logic to validate transactions, ensure sufficient balances, and handle smart contract interactions.
2. **Traffic Controller (CometBFT)**: This component, powered by the CometBFT consensus engine, is the backbone of MANTRA Chain's decentralized decision-making process. It ensures that all nodes agree on the order and validity of transactions, even in the face of potential network disruptions or malicious actors. This is crucial for maintaining a single, consistent version of the blockchain across the entire network. The CometBFT engine utilizes a voting mechanism where nodes propose blocks of transactions and vote on their validity. Once a block receives enough votes, it's added to the blockchain.
3. **Translator (ABCI Interface)**: This interface acts as a bridge between the blockchain's core logic and the decentralized applications (dApps) built on top of it. The ABCI defines a set of standardized messages and responses that allow dApps to interact with the blockchain without needing to understand its intricate inner workings. This abstraction simplifies dApp development and promotes interoperability between different applications on the MANTRA Chain.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXetGuklweOWggdcfNxhWzCfoWbclzBjsx3339A3bf2gvIiI2gIrqav7bu2bs8g34NiLP2Y-7SKTW0ZzD-Q2JJ2zTRWPTpMKzWMo-kiwAEu7bDMhexH34frDDuwa09QWynpY7ypiFtzTU5c00Ev1099pFDY?key=1Fe5FFVv1GXQSTaUn6PLrw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L7%20Image%202.gif?raw=true)

In addition to these core components, MANTRA Chain nodes also handle network communication, peer discovery, and data synchronization. They participate in the gossip protocol to exchange information with other nodes and maintain a synchronized view of the blockchain, ensuring that all nodes are on the same page and the network remains decentralized and resilient.

## MANTRA Chain Network Architecture: The City That Never Sleeps

MANTRA Chain's network architecture is a multi-layered marvel, carefully crafted to ensure security, efficiency, and interoperability. Each layer plays a distinct role, working together harmoniously to create a powerful symphony of decentralized finance. Let's take a quick tour:

1. **Staking Layer:** This is the bedrock of security and community governance, where users can stake their $OM tokens to participate in network operations and earn rewards.
2. **Interoperability Layer:** The bridge that connects MANTRA Chain to the wider blockchain universe, allowing for seamless communication and asset transfer across different chains.
3. **Execution Layer:**
- **Generic Modules:** Most blockchains in the Cosmos ecosystem incorporate these generic execution modules, it's where simple transactions are processed and user-created smart contracts are executed.
- **Mantra Modules:** In addition to generic execution modules, the Mantra blockchain includes a collection of modules that add specific functionalities applicable to Mantra's vision and are unique to the Mantra blockchain.
4. **Application Layer:** This is where the fun begins! The application layer is the user-facing interface where you'll find all the exciting dApps that make MANTRA Chain so unique.

This harmonious interplay of layers empowers MANTRA Chain to be a flexible, scalable, and user-centric platform for the future of decentralized finance.

![https://lh7-us.googleusercontent.com/docsz/AD_4nXfKsGLFso2xSQqYv1K3uHWDgpN9DQeezXEIFwKU-xC9JMf3ZcQTeS8VVI1huT1JLdu9FW2uCUdd8W8ZkG5rTaejs_o3lhXDaty1h23KcAMWbiOOJJ7_cmI_yVID6jdpvYY-t_ko4meCsnYXwFf-FlXvP-p-?key=1Fe5FFVv1GXQSTaUn6PLrw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L7%20Image%203.gif?raw=true)

## Wrap Up

With this backstage pass to MANTRA Chain's architecture, you've gained a deeper understanding of the technology that powers this innovative platform. In our next lesson, we'll delve even deeper, exploring the specifics of each layer and how they work together to create a robust and user-friendly blockchain ecosystem. Get ready for a closer look at the engine room, the bridges, and the grand stage of MANTRA Chain!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/3.%20Understanding%20MANTRA's%20Architecture%20/Lesson%207%20-%20Understanding%20MANTRA%20Chain%E2%80%99s%20Architecture.md

Understanding MANTRA Chain’s Architecture

# Deep dive into MANTRA Chain Network Architecture

Alright people, Now that you guys had a fairly good intro into the inner workings of MANTRA. let's just zoom in and take a look at the detailed picture: the network architecture. This is where the real magic happens, where all the different pieces of the puzzle come together to create a vibrant, secure, and decentralized ecosystem.

Think of the network architecture as the sprawling metropolis that houses all the blockchain's bustling activity. Each node is like a building within this city, each playing a unique role in the overall function of the urban landscape. The network architecture ensures these buildings are interconnected, allowing for the efficient flow of information, goods, and services.

## A Five-Layer Symphony: Overview of the Network Architecture

In our previous lesson, we introduced MANTRA Chain's layered architecture, a well-oiled machine built for speed, security, and versatility. We gave you a bird's-eye view of the different layers and their functions. Now, it's time to roll up our sleeves and get our hands dirty as we take a deep dive into each layer. Get ready to explore the inner workings of this groundbreaking blockchain and discover the technical marvels that make it tick!

![https://lh7-us.googleusercontent.com/docsz/AD_4nXd9QkF7sF7sVjwJpUjse8IApeAdIL69tbXf1zx5QWTsB8Yr57lNYi1wUqNRpA6MJfoGQ_wZL5itlQNUrnyIPotO4GXmrWqviLc2t3FIcJj6bjMFcL3O6gY3NZpF3hYlz8c-BYO5y8pVse5jbz9KQ8a8kuMT?key=b8IlQPLs_vowVQ2diyX4Pw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L8%20Image%201.png?raw=true)

### Layer 1: Staking Layer – Your Ticket to Participation

The staking layer is where the MANTRA Chain community really shines. It's your chance to become an active participant, not just a spectator. By staking your $OM tokens, you're not only helping to secure the network (like a security guard at a concert) but also earning rewards for your contribution.

Staking involves locking up your $OM tokens as collateral, which helps validate transactions and maintain the blockchain's integrity. In return, you receive additional OM tokens as a reward, making it a win-win situation for both you and the network.

But the benefits don't stop there. Staking also gives you a voice in the governance of MANTRA Chain. You can vote on proposals that affect the future direction of the platform, ensuring that it remains decentralized and community-driven. It's like having a say in how your favorite band runs its next tour!

### Layer 2: Interoperability Layer – A Passport to the Multi-Chain World

MANTRA Chain isn't content to be just another blockchain; it wants to play well with others. That's why it leverages the Inter-Blockchain Communication (IBC) protocol, a revolutionary technology that enables seamless communication and asset transfer between different blockchains.

Think of the IBC protocol as your passport to a multi-chain world. It allows you to effortlessly move your tokenized assets between MANTRA Chain and other Cosmos-based blockchains. This means you can explore new DeFi opportunities, access a wider range of assets, and participate in cross-chain collaborations.

### Layer 3: Module Layer – The Blockchain's Swiss Army Knife

The module layer is where MANTRA Chain's flexibility and adaptability truly shine. It's a collection of specialized modules, each designed to address a specific need or function. Think of it as the Swiss Army knife of the blockchain world, packed with tools for every occasion.

- **MANTRA Compliance Module:** In the complex world of finance, regulatory compliance is a must. This module ensures that all activities on the blockchain adhere to the necessary legal and regulatory frameworks, giving users and institutions peace of mind. It's like having a team of expert lawyers working tirelessly to keep everything above board.
- **MANTRA Token Service Module:** This module makes it easy for anyone to create, issue, and manage their own digital assets on the MANTRA Chain. It's like a user-friendly token factory, empowering you to tokenize your ideas and create your own digital economy.
- **MANTRA Assets Module:** This module is the heart of MANTRA Chain's mission, enabling the tokenization of real-world assets. It's like a magical portal that allows you to bring your physical assets into the digital world, unlocking liquidity and creating new investment opportunities.
- **MANTRA Guard Module:** This module acts as a gatekeeper, ensuring that only verified users and dApps can participate in the network. It's like a security checkpoint, keeping out bad actors and ensuring the safety of your assets.
    
![https://lh7-us.googleusercontent.com/docsz/AD_4nXeiAK_fWfpVTNQXGvIHWyJL0ZsR_WimyM25g_Z4N7B08lniogdT7G8QIAtLT-r9_7PBWd8Vi67evSX1yKk5D7-SKJ_ymS6Kgh8zardNwPXWPnzVRY5WghtI1K4_WgY-keixxHfOwyOTB83jzaG1AXpPhNvL?key=b8IlQPLs_vowVQ2diyX4Pw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L8%20Image%202.gif?raw=true)
    

### Layer 4: Execution Layer – The Engine Room of the Blockchain

Let's step into the bustling heart of MANTRA Chain—the execution layer. This is where the real action happens, where the intricate dance of code and data transforms abstract concepts into tangible results. Think of it as a digital factory, buzzing with activity as transactions are processed, smart contracts execute their logic, and the blockchain maintains its unwavering rhythm.

- **Cosmos SDK: The Backbone of Scalability and Interoperability:** The execution layer is built upon the rock-solid foundation of the Cosmos SDK. This modular framework not only provides the structure for MANTRA Chain but also ensures it can scale to handle the growing demands of the DeFi world. It's like the steel beams and concrete that hold up a skyscraper, allowing it to reach for the stars. Moreover, the Cosmos SDK's inherent interoperability enables MANTRA Chain to communicate effortlessly with other blockchains in the Cosmos ecosystem. This means your tokenized assets can travel between blockchains as easily as you hop on a plane.
- **CosmWasm Smart Contracts: The Digital Rulebook:** Smart contracts are the self-executing contracts that automate processes on the blockchain, and MANTRA Chain uses CosmWasm to create them. CosmWasm is like the blockchain's legal team, making sure everything runs smoothly and fairly. Written in WebAssembly, a high-performance and secure language, these smart contracts are like digital vending machines: you put in your tokens, and the contract automatically dispenses the agreed-upon outcome.
- **P2P Networking: The Blockchain's Gossip Mill:** Imagine a group of friends sharing the latest news and rumors. That's basically how peer-to-peer (P2P) networking works on MANTRA Chain. Each node in the network acts as both a teller and a listener, sharing information about transactions and keeping the ledger in sync. It's like a super-fast and secure gossip network that ensures everyone stays in the loop.
- **Tendermint Consensus: The Democratic Decision-Maker:** In a decentralized world, everyone gets a say. Tendermint, the consensus mechanism used by MANTRA Chain, is like a digital democracy. It ensures that all nodes agree on the validity and order of transactions through a voting process. This keeps things fair and prevents any single node from throwing a tantrum and disrupting the network.
    
![https://lh7-us.googleusercontent.com/docsz/AD_4nXfI0c24yVHDf4gLdD8S8jtpb5ia3hvGRFvsnoK7QuVgh7twGD4XzWZw-ZwojRbjZz4T2dpj6v7jMfqDNzmTlrZNjlBn_-uZ5h5YdchOWElid1mZE3MiubR9Qg_HkgTO-MPR0-g2mfkG4mJ10BmGBpG9fMA?key=b8IlQPLs_vowVQ2diyX4Pw](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets-for-MANTRA-C1/MANTRA%20C1%20L8%20Image%203.gif?raw=true)
    

### Layer 5: Application Layer – The Funhouse of Decentralized Apps

Get ready to enter the funhouse of MANTRA Chain—the application layer! This is where you, the user, get to play with all the cool decentralized apps (dApps) that make this blockchain so exciting.

- **MANTRA DEX: Your One-Stop Token Shop:** Need to swap some tokens? Head over to the MANTRA DEX, a decentralized exchange where you can trade a variety of tokenized assets directly with other users, cutting out the middleman. It's like a digital marketplace where you can find unique treasures and make a profit.
- **Other dApps: The Wild West of DeFi:** The MANTRA DEX is just the tip of the iceberg. The application layer is where you'll find a whole range of dApps that let you lend, borrow, yield farm, and explore the wild world of DeFi. These dApps are built on top of MANTRA Chain's robust architecture, taking advantage of its security, interoperability, and customizability to create a whole new financial playground.

## Wrap Up

MANTRA Chain's architecture is more than just a bunch of technical jargon. It's a testament to the power of innovation, collaboration, and the relentless pursuit of a decentralized future. With its robust infrastructure, secure consensus mechanism, and modular design, MANTRA Chain is poised to revolutionize the financial landscape and empower individuals and businesses alike.

As MANTRA Chain continues to evolve, we can expect even more exciting developments and use cases. The future of tokenized real-world assets is bright, and MANTRA Chain is leading the charge.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/3.%20Understanding%20MANTRA's%20Architecture%20/Lesson%208%20-%20Deep%20dive%20into%20MANTRA%20Chain%20Network%20Architecture.md

Deep dive into MANTRA Chain Network Architecture

# Wrap Up

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

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

## What we learned so far

In this course, we got a thorough understanding of MANTRA Chain. Let’s see what we covered:

- Explored the foundation upon which MANTRA Chain is built and learned about the reasons why MANTRA selected the Cosmos ecosystem.
- Uncovered the exciting world of real world assets (RWAs) and explored multiple use cases.
- Got up close and personal with MANTRA Chain, understanding its unique vision and mission to provide everyone with the infrastructure to bringing on real world assets (RWAs) onto the blockchain.
- Traced MANTRA Chain's journey, from its inception to its current position as a leading player in the real world asset segment.
- Explored the vast array of real-world applications for MANTRA Chain, from fractional real estate ownership to tokenized art investments.
- Peeked under the hood to understand the cutting-edge technology that powers MANTRA Chain and ensures its security, scalability, and interoperability.
- Taken a deep dive into the inner workings of MANTRA Chain's network architecture, understanding its components and how they work together to create a robust and efficient platform.

## ⚒️ A small yet important request

Here is great news for you! This is a 100% open-source project like all the other projects on our platform. You can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects). If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://discord.gg/Jf4ArqVb) and GitHub, too.

While you're learning, don't forget to join the vibrant MANTRA Chain community!

- **Follow & Subscribe:** Stay in the loop on [X (formerly Twitter)](https://twitter.com/MANTRA_Chain), [LinkedIn](https://www.linkedin.com/company/mantrachain/), [YouTube](https://www.youtube.com/@MANTRAChain) and [Instagram](https://www.instagram.com/mantra_chain/).
- **Chat & Connect:** Join the conversation on [Discord](https://discord.gg/gfks4TwAJV) & [Telegram](https://t.me/MANTRA_Chain), and read about MANTRA Chain on [Medium](https://mantrachain.medium.com/).

By actively participating in the community, you'll gain valuable insights, network with like-minded individuals, and stay at the forefront of the decentralized finance revolution.

And of course, don't forget to show your support for Metaschool as well!

- **Star the Metaschool Repository:** Give us a star on [GitHub](https://github.com/0xmetaschool/Learning-Projects) to show your appreciation for our educational resources.
- **Follow Metaschool on Social Media:** Stay connected with us on [X (formerly Twitter)](https://twitter.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) for the latest updates and course announcements.
- **Subscribe to the Metaschool [YouTube Channel](https://www.youtube.com/@0xmetaschool/):** Watch our educational videos and tutorials to expand your blockchain knowledge.

## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Introduction%20to%20MANTRA%20Chain/4.%20Wrap%20Up/Lesson%209%20-%20%20Wrap%20up.md

Wrap up

Introduction to MANTRA Chain

This course has been meticulously crafted to build upon your foundational knowledge and guide you towards developing on Mantra Chain. It will provide you with a solid understanding of CosmWasm, the smart contract platform essential for Mantra Chain development. You'll learn to deploy your first smart contract using CosmWasm, while gaining insight into the language's structure and smart contract composition. You'll explore Rust fundamentals as they apply to CosmWasm, including variables, constants, data types, traits, structs, and control flow.

# What Are We Building Today?

Hey there, MANTRA masters! 👋

Welcome back to the exciting world of decentralized finance (DeFi) and real-world assets (RWAs)! We're stoked you conquered our first course and are ready to level up your MANTRA Chain skills.  🎉

Blockchain tip: Following project repos on GitHub isn't just about code - it's your ticket to the inner circle. From airdrops to early access, the perks of being an engaged community member can be surprising. Why not start by following [MANTRA's GitHub](https://github.com/MANTRA-Finance)?

In this course, we're not just dipping our toes; we're diving headfirst into the world of building decentralized applications (dApps) on MANTRA Chain. Think about it: fractional ownership of real estate, art, commodities, and more—all enabled by the secure, transparent infrastructure of MANTRA Chain, designed to foster compliant tokenization and trading. This course is your toolkit for turning these possibilities into reality!

Remember all the awesome stuff we covered in the first course? The Cosmos ecosystem, the ins and outs of RWAs, the importance of regulatory compliance, and MANTRA's vision to merge TradFi and DeFi, its architecture? Well, this course builds on that foundation, empowering you to create dApps that truly leverage the power of MANTRA Chain.

## The To-Do dApp: Your Launchpad to CosmWasm Mastery

But why build a to-do dApp, you ask? Well, get ready to roll up your sleeves and dive into the real-world action of blockchain development! This seemingly simple app is your launchpad into the exciting world of CosmWasm development on MANTRA Chain.

![aptos-c4-l10.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/6.%20Conclusion/1.%20Wrap%20Up/aptos-c4-l10.webp?raw=true)

Here's why this to-do dApp is more than just checking off tasks:

- **Hands-On Learning:** Building a to-do dApp is the most hands-on and engaging way to grasp the core concepts of CosmWasm. You'll learn by doing, creating a working application from scratch.
- **Rust Fundamentals:** You'll dive into the world of Rust, the powerful and secure language that fuels CosmWasm. By building this dApp, you'll gain valuable experience with Rust syntax, data structures, and functions, setting the stage for more complex projects in the future.
- **Deployment and Interaction:** The thrill of coding doesn't end on your local machine. You'll deploy your dApp onto the MANTRA testnet, interacting with it in a real blockchain environment. This hands-on experience will give you a taste of what it's like to bring your decentralized creations to life.

Building a to-do dApp might seem like a small step, but it's a giant leap towards mastering the MANTRA Chain and unleashing your potential as a blockchain developer. So, let's get started on this exciting journey!

## Course Overview

![MANTRA C2 Image 3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/1.%20What%20Are%20We%20Building%20Today/MANTRA_C2_Image_3.webp?raw=true)

Here's the roadmap to becoming a MANTRA dApp developer:

- **Introducing CosmWasm:** Get acquainted with CosmWasm, the smart contract platform powering MANTRA Chain.
- **Rust Fundamentals:** Master the basics of Rust, the language behind CosmWasm development.
- **Development Environment Setup:** Prepare your development environment and connect to the MANTRA testnet.
- **CosmWasm Deep Dive**: Master messages, queries, state management, and more.
- **Hands-On dApp Creation:** Create your own decentralized to-do list dApp on MANTRA Chain!

## Who's this Course for?

This course is designed for anyone with a basic understanding of blockchain technology and a passion for building decentralized applications. Whether you're a seasoned developer or just starting out, you'll find valuable insights and hands-on experience to accelerate your journey into the world of CosmWasm and MANTRA Chain.

## What's in it for You?

By the end of this course, you'll have:

- A solid grasp of CosmWasm and Rust development.
- The ability to build and deploy your own dApps on MANTRA Chain.
- A deeper understanding of how blockchain technology can revolutionize real-world asset management.
- A sweet NFT to show off your newfound skills and unlock exclusive opportunities within the MANTRA ecosystem.

## Proof of completion

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

![nft-mantra-c2-ezgif.com-optimize.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/1.%20What%20Are%20We%20Building%20Today/nft-mantra-c2-ezgif.com-optimize.webp?raw=true)

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

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

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


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

What Are We Building Today?

# Cosmos and Wasm = CosmWasm

Alright devs, get ready to level up your blockchain development skills as we dive into the exciting world of MANTRA Chain and CosmWasm. Before we unleash your coding prowess, let's build a solid foundation to ensure your dApp-building journey is smooth and successful!

In this lesson, we'll revisit the mighty Cosmos ecosystem, that vast network of interconnected blockchains where MANTRA Chain resides. Then, we'll unlock the secrets of WebAssembly (Wasm), the magic behind CosmWasm's flexibility and power.

By the end of this lesson, you'll have a rock-solid foundation in the key technologies that underpin MANTRA Chain. So, buckle up and get ready for liftoff, because we're about to launch into the exciting world of CosmWasm smart contract development! 🚀

## Revisiting the Cosmos Ecosystem

In the first course of the MANTRA Chain learning track, we took an in-depth look at the Cosmos ecosystem, the foundation upon which MANTRA Chain is built. As a quick refresher, let's revisit the key concepts of this innovative blockchain network.

### What is the Cosmos Ecosystem?

Imagine a universe of interconnected blockchains, each with its own unique strengths and features, working together seamlessly. That's the Cosmos ecosystem. It's a network of independent blockchains that communicate and share data, creating a more scalable, flexible, and interoperable blockchain landscape.

### Key Elements of the Cosmos Ecosystem

![Mantra Chain.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/2.%20Cosmos%20and%20Wasm%20=%20CosmWasm/Mantra_Chain.webp?raw=true)

Here are the key elements of the Cosmos ecosystem.

- **Cosmos SDK:** A powerful framework for building custom blockchains. Think of it as a set of Lego blocks that developers can use to create their own unique blockchain applications.
- **CometBFT:** The heart of the Cosmos ecosystem, providing a robust consensus mechanism that ensures network security and data integrity.
- **Inter-Blockchain Communication (IBC):** The secret sauce that enables different blockchains within the Cosmos ecosystem to communicate and share data. It's like a universal translator for blockchains.
- **CosmWasm:**  This smart contract platform leverages WebAssembly (Wasm) to bring flexibility and security to the Cosmos ecosystem. It allows developers to write smart contracts in various programming languages, making it easier to build powerful decentralized applications (dApps).

By understanding the Cosmos ecosystem, you're gaining a solid foundation for your journey into CosmWasm development on MANTRA Chain. Now, let's unlock the power behind this development by diving into the fascinating world of WebAssembly (Wasm)!

## Before CosmWasm: The Smart Contract Challenge

Imagine building a house where everyone speaks a different language. The plumbers only know French, the electricians only speak Spanish, and the carpenters only understand Japanese. Communication would be a nightmare, right? You'd spend more time deciphering each other than actually building the house!

This is a bit like the situation with smart contracts, different blockchain platforms have their own unique languages and environments, making it difficult for developers to write code that could work across multiple blockchains. This created a fragmented landscape where smart contracts were often isolated to specific platforms, limiting their potential reach and impact.

### Wasm: The Universal Language for Smart Contracts

Enter WebAssembly (Wasm). Just like a universal translator that allows people from different cultures to understand each other, Wasm provides a common language for smart contracts.

Think of Wasm as a universal language for the web, allowing different programming languages to work together seamlessly. It enables developers to code in different languages like Rust, C++, or Go, then compile it into a universal format(Binary Instruction Format - a series of low-level instructions (like 0s and 1s)) that any blockchain can understand and execute. With Wasm, you can write your code once and deploy it across multiple blockchains, making smart contracts incredibly portable, reusable, and accessible

![MANTRA C2 Image 1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/2.%20Cosmos%20and%20Wasm%20=%20CosmWasm/MANTRA_C2_Image_1.webp?raw=true)

### Wasm in the Cosmos Ecosystem

Now, let's bring this back to the Cosmos ecosystem. Remember how Cosmos is all about creating a network of interconnected blockchains? Well, Wasm plays a crucial role in making this vision a reality. By providing a common execution environment for smart contracts, Wasm enables flexibility and portability within the Cosmos ecosystem.

This means that developers can write smart contracts in a language like Rust, compile them into Wasm, and deploy them on any blockchain that supports CosmWasm. While Wasm itself doesn't directly enable interoperability between blockchains, it standardizes how smart contracts are executed. This standardization is crucial for the Cosmos ecosystem because it facilitates smoother interactions and integrations between different blockchains.

In summary, Wasm allows smart contracts to be more portable and versatile across the Cosmos ecosystem, enhancing the ability for blockchains to interact and share functionality.

## Cosmos + Wasm = CosmWasm

![MANTRA C2 Image 2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/2.%20Cosmos%20and%20Wasm%20=%20CosmWasm/MANTRA_C2_Image_2.webp?raw=true)

Yes, as already hinted by the heading, CosmWasm is the Cosmos (Cosm) way of utilizing WebAssembly (Wasm), hence its name. It's a smart contract platform designed to bring flexibility, speed, and security to decentralized applications (dApps).

CosmWasm allows developers to write smart contracts in familiar programming languages, like Rust, and then compile them into Wasm bytecode. This bytecode can run on any blockchain that supports the Cosmos SDK, making it incredibly versatile and portable. By leveraging Wasm, CosmWasm ensures that smart contracts execute quickly and securely, meeting the high standards  for blockchain applications.

**But why do we need CosmWasm?** Why not use Wasm directly? The answer lies in the need for a specialized platform that integrates seamlessly with the Cosmos SDK. While Wasm provides a universal execution environment, CosmWasm adds tools, libraries, and support to make Wasm practical for blockchain development. CosmWasm handles the specifics of blockchain interactions, making it easier and more efficient for developers to create and deploy smart contracts within the Cosmos ecosystem.

## Wrap Up

In this lesson, we've revisited the Cosmos ecosystem, explored the inner workings of WebAssembly (Wasm), how Wasm is integrated into Cosmos and introduction to CosmWasm.

Throughout this course, we'll explore how CosmWasm works, its key features, and how you can use it to build robust, scalable dApps on the MANTRA Chain and beyond. Whether you're an experienced developer or just getting started with blockchain technology, CosmWasm offers a powerful toolkit to create the next generation of decentralized applications.

In the next chapter, we'll delve deeper into the Cosmos SDK and CosmWasm. This foundational knowledge is crucial for fully grasping the development process as we move forward.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/1.%20Introduction%20to%20CosmWasm/2.%20Cosmos%20and%20Wasm%20%3D%20CosmWasm.md

Cosmos and Wasm = CosmWasm

# Introduction to the Cosmos SDK

Buckle up, MANTRA explorers, because we're about to embark on a deep dive into the very heart of the development ecosystem! In our previous lesson, we unveiled the magic of WebAssembly (Wasm) and its role in making CosmWasm a powerful smart contract platform. Now, it's time to explore the foundation upon which this magic unfolds: the Cosmos Software Development Kit, or Cosmos SDK for short.

You might have caught a glimpse of the Cosmos SDK in our earlier discussions, but we're about to take a closer look under the hood. Think of the Cosmos SDK as a versatile toolbox, packed with everything you need to build your own custom blockchains, tailored to your specific needs and vision. It's the backbone of the entire Cosmos ecosystem, and understanding its inner workings is crucial for mastering CosmWasm development on MANTRA Chain.

In this lesson, we'll uncover:

- **The Cosmos SDK introduction:** We'll explore its usages, key components, and how it simplifies the complex process of building blockchains.
- **Modules Galore:** We'll discover the wide range of pre-built modules that the Cosmos SDK offers, from staking and governance to tokenomics and more.
- **The CosmWasm Connection:** We'll see how CosmWasm seamlessly integrates with the Cosmos SDK, allowing you to build powerful smart contracts that interact with the blockchain.

![MANTRA C2 L3 - Image 1 (2).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/3.%20Introduction%20to%20the%20Cosmos%20SDK/MANTRA_C2_L3_-_Image_1_(2).webp?raw=true)

By the end of this lesson, you'll have a solid grasp of the Cosmos SDK and its pivotal role in the MANTRA Chain universe. So, let's dive in and explore the inner workings of the Cosmos SDK!

## The Cosmos SDK: Your Blockchain Construction Kit

Picture this: you're an architect, but instead of designing buildings, you're creating entire blockchains! Sounds daunting, right? That's where the Cosmos SDK swoops in like your trusty blueprint.

The Cosmos SDK (Software Development Kit) is a powerful, open-source framework designed to streamline the process of building custom blockchains. It's like a toolbox filled with pre-built modules, each serving a specific purpose in the blockchain's architecture. These modules cover essential functions like:

- **Token management:** Creating and managing custom tokens for your blockchain.
- **Staking:** Enabling users to stake their tokens to participate in network security and governance.
- **Governance:** Implementing voting mechanisms to allow token holders to propose and vote on changes to the network.
- **Tokenomics:** Designing the economic model of your blockchain, including inflation rates, reward mechanisms, and transaction fees.

![MANTRA C2 L3 Image 2 (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/3.%20Introduction%20to%20the%20Cosmos%20SDK/MANTRA_C2_L3_Image_2_(1).webp?raw=true)

With the Cosmos SDK, you don't have to start from scratch. You can simply pick and choose the modules you need, customize them to your liking, and voilà – you have a brand new blockchain ready to go! 

Think of it like building with Lego blocks – you can pick and choose the modules you need, rearrange them, and even create your own custom modules to add unique functionalities.  This modularity offers immense flexibility and adaptability, allowing you to build everything from public Proof-of-Stake (PoS) blockchains to private Proof-of-Authority (PoA) blockchains, all within the same framework.

Even better, the Cosmos SDK goes beyond modularity by giving you the freedom to swap out the consensus engine itself! You can choose between Tendermint's CometBFT, known for its speed and security, or the Rollkit, a cutting-edge alternative. This flexibility allows you to tailor your blockchain's performance and characteristics to perfectly match your project's requirements.

The Cosmos SDK offers a user-friendly and efficient way to bring your blockchain vision to life. With its modular architecture, customizable components, and a vast array of features, it's the perfect toolkit for building the next generation of decentralized applications.

## Key Modules of Cosmos SDK

As we have seen above, one of the most significant advantages of the Cosmos SDK is its modularity. Think of it as a buffet where you can pick and choose the dishes you like best. Each module is self-contained and can be easily plugged into the blockchain's architecture. This gives developers incredible flexibility to create blockchains that perfectly suit their specific use cases.

Here's a quick rundown of some key Cosmos SDK modules:

- **Auth:** Manages accounts and authentication.
- **Bank:** Handles token transfers and account balances.
- **Staking:** Enables staking and validator management.
- **Governance:** Implements on-chain governance mechanisms.
- **Distribution:** Manages token distribution and rewards.
- **Slashing:** Penalizes validators for malicious behavior.
- **Crisis:** Handles emergency upgrades and fixes.
- **Evidence:** Tracks and punishes fraudulent behavior.
- **Consensus:** Consensus module for modifying CometBFT's ABCI consensus params.
- **Mint** - Creation of new units of staking tokens.
- **and many more....**

![Mantra Chain C2 L3 Image 3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/3.%20Introduction%20to%20the%20Cosmos%20SDK/Mantra_Chain_C2_L3_Image_3.webp?raw=true)

In addition to these core modules, the Cosmos SDK also supports a wide range of third-party modules developed by the community. This means you have an ever-growing library of tools at your disposal, making it easier than ever to build a custom blockchain that meets your specific needs.

## CosmWasm and the Cosmos SDK: A Perfect Pairing for Smart Contracts

Now, let's bring CosmWasm back into the picture. Remember, CosmWasm is the smart contract platform that allows developers to write code in languages like Rust and compile it into Wasm bytecode. This bytecode can then be executed on any Cosmos-based blockchain, including MANTRA Chain.

So, how does CosmWasm interact with the Cosmos SDK? CosmWasm is written as a module that can plug into the Cosmos SDK. Think of it as a dynamic duo working together to create powerful decentralized applications. The Cosmos SDK provides the underlying infrastructure for the blockchain, including the core modules mentioned above. CosmWasm acts as a layer on top of the SDK, providing the ability to execute smart contracts and create complex dApps.

This integration allows developers to leverage the full power of the Cosmos SDK while also taking advantage of the flexibility and security offered by CosmWasm. This means you can build sophisticated dApps that can interact with other blockchains in the Cosmos ecosystem, handle complex financial transactions, and create entirely new use cases for blockchain technology.

MANTRA Chain, built on the Cosmos SDK, inherits its modularity and flexibility, allowing for seamless integration of custom features and functionalities tailored specifically for real-world asset tokenization. This powerful combination enables MANTRA Chain to offer a robust and secure platform for building decentralized applications that bridge the gap between traditional and onchain finance.

## That's a Wrap

Now, armed with this knowledge, you have a solid foundation to embark on your journey of building innovative dApps on MANTRA Chain. So, get ready to unleash your creativity and build the future of onchain finance!

In the next lesson, we'll delve deeper into CosmWasm, exploring its architecture, key components, and how you can use it to build innovative dApps on the MANTRA Chain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/1.%20Introduction%20to%20CosmWasm/3.%20Introduction%20to%20the%20Cosmos%20SDK.md

Introduction to the Cosmos SDK

# CosmWasm & Rust

GM builders, let's get this CosmWasm party started! We've already laid the groundwork by understanding the Cosmos ecosystem, the Cosmos SDK, and the versatility of WebAssembly (Wasm). Now, it's time to unravel the power of CosmWasm, the smart contract platform that empowers MANTRA Chain.

In this lesson, we'll demystify CosmWasm and its key features and understand why Rust is its language of choice. Don't worry if you're new to Rust – we'll cover the basics of this powerful language as we build our dApp later in the course. 

Buckle up and get ready to dive into the building blocks of MANTRA Chain dApps and explore CosmWasm!

## CosmWasm: The Power of Secure and Flexible Smart Contracts on MANTRA Chain

As we've seen in our previous lessons, WebAssembly (Wasm) is a versatile technology that allows code written in various languages to run on the blockchain. CosmWasm leverages this power by acting as a smart contract platform built on Wasm. This approach brings unmatched flexibility and security to the blockchain world. 

CosmWasm allows developers to write smart contracts in various programming languages, including the powerful Rust language. These contracts are then compiled into Wasm bytecode, a universal format that can be executed on any blockchain supporting Wasm, including MANTRA Chain.

![Mantra Chain C2 L4 Image 1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/4.%20CosmWasm%20&%20Rust/Mantra_Chain_C2_L4_Image_1.webp?raw=true)

In more technical terms, CosmWasm is a framework built on top of the Cosmos SDK that enables the execution of WebAssembly (Wasm) bytecode as smart contracts on a Cosmos blockchain. CosmWasm contracts exist within a sandboxed environment, interacting with the blockchain through a defined set of APIs. This ensures security by preventing unauthorized access to system resources and isolating contracts from each other. This approach brings unmatched flexibility and security to the blockchain world, allowing for high-performance, cross-chain compatible smart contracts.

## Why Rust? The Secret Sauce of CosmWasm

Rust is a modern, high-performance programming language that prioritizes safety, speed, and efficiency. These qualities make it the perfect match for both CosmWasm and MANTRA Chain. MANTRA Chain, with its focus on real-world asset tokenization and secure financial applications, demands smart contracts that are reliable, efficient, and resistant to vulnerabilities. 

Rust's emphasis on memory safety ensures that contracts are robust and can handle sensitive financial data with confidence. Additionally, Rust's performance benefits contribute to the overall scalability and responsiveness of dApps built on MANTRA Chain.

Rust's key features include:

- **Memory Safety:** Rust's strict ownership rules are like a safety net for your code. They help prevent common errors like those pesky null pointers and buffer overflows, keeping your smart contracts rock solid.
- **Concurrency Without Chaos:** Have you ever tried juggling multiple tasks at once? It can get messy, right? Rust's design makes it easier to write code that does multiple things simultaneously. Its type system and ownership rules enable safe concurrent programming without the risk of data races(where multiple tasks try to change the same data at the same time).
- **Zero-Cost Abstractions:** Rust lets you write clean, high-level code without sacrificing performance. It is comparable in efficiency to languages like C or C++. This means you can build sophisticated smart contracts without sacrificing performance.
- **Expressive Type System and Pattern Matching:** Rust's strong type system and powerful pattern matching capabilities make your code more robust and easier to reason about. Pattern matching allows for concise and expressive handling of complex data structures, improving code readability and maintainability.
- **Robust Error Handling:** Rust's error handling system is like a safety harness for your code. It forces you to deal with errors head-on, making your smart contracts more resilient and less likely to crash.
- **Cargo: Your Trusty Toolkit:** Rust comes with its own package manager and build system called Cargo, which makes it a breeze to manage dependencies and build your projects.

![Mantra Chain C2 L4 Image 2.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/4.%20CosmWasm%20&%20Rust/Mantra_Chain_C2_L4_Image_2.webp?raw=true)

But wait, there's more! Rust has a vibrant and welcoming community that's always there to lend a helping hand. Plus, it's got a treasure trove of tools and libraries (called "crates") for all sorts of tasks. So, whether you're a seasoned Rustacean or a newbie, you'll find plenty of resources to help you on your CosmWasm journey. 

Don't worry if you haven't dabbled in Rust before; we'll cover the basics as we build our awesome dApp. Just remember, with Rust in your corner, you'll be well-equipped to tackle the challenges of blockchain development and create amazing applications on MANTRA Chain.

## Unleashing the Power of Rust and CosmWasm on MANTRA Chain

By combining the strengths of Rust, Wasm, and the Cosmos SDK, MANTRA Chain offers a unique development environment that's both powerful and accessible. You can leverage the safety and performance of Rust to write secure and efficient smart contracts that seamlessly interact with the wider Cosmos ecosystem through the IBC protocol.

![Mantra Chain C2 L4 Image 3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/4.%20CosmWasm%20&%20Rust/Mantra_Chain_C2_L4_Image_3.webp?raw=true)

- **Security and Reliability:** Rust's strict rules ensure robust and vulnerability-resistant smart contracts.
- **Performance and Efficiency:** Rust's speed and Wasm's optimization enable high-performance dApps.
- **Cross-Chain Interoperability:** Seamlessly connect and transfer assets across Cosmos blockchains.
- **Developer-Friendly Tooling:** MANTRA Chain supported by CosmWasm and Rust, provides comprehensive tools and libraries for streamlined development.
- **Community-Driven Innovation:** A vibrant community fosters collaboration and pushes the boundaries of CosmWasm development

Whether you're a seasoned blockchain developer or just starting your journey, MANTRA Chain and CosmWasm offer the perfect platform to turn your innovative ideas into reality. With its focus on security, performance, interoperability, and community-driven development, MANTRA Chain is paving the way for a new era of decentralized finance applications.

## Wrap-Up: Gearing Up for dApp Development on MANTRA Chain

In this lesson, we've taken a tour of the technologies that power MANTRA Chain. We've learned about CosmWasm, introduced you to Rust, the high-performance programming language that makes CosmWasm development a breeze and explored the unique features that make it perfect for building secure and efficient smart contracts.

And that's not all! We've delved into how MANTRA Chain leverages the power of Rust and CosmWasm to create a secure, interoperable, and community-driven environment for building the next generation of decentralized financial applications.

Ready to take the next step? In our next lesson, we'll get our hands dirty and set up your development environment, equipping you with the essential tools to start building your very own CosmWasm smart contracts on MANTRA Chain. Get excited, because the real fun is just beginning!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/1.%20Introduction%20to%20CosmWasm/4.%20CosmWasm%20%26%20Rust.md

CosmWasm & Rust

# Setting Up the Development Environment

Welcome back, people! In our last lesson, we explored the basics of CosmWasm development, why Rust is essential, and how by combining the strengths of Rust, Wasm, and the Cosmos SDK, MANTRA Chain offers a unique development environment that's both powerful and accessible

Now, it’s time to set up our development environment. We’ll cover the tools you need, install dependencies like Rust and Docker, set up a local environment, configure your IDE, and connect to the MANTRA DuKong Testnet. The MANTRA DuKong Testnet is a practice area for testing new features before they go live on MANTRA Chain's main network. It's like a sandbox where developers can try things out safely to make sure everything works properly. If you’re hearing about these tools like Docker for the first time, don’t worry! We’ll guide you through each step to set them up and use them. This will be a valuable new skill-set to add to your arsenal.

## The Pre-requisites

A core component that we need to set up is `mantrachaind`, the command-line interface (cli) tool to interact with MANTRA Chain. We'll cover more about what it does later, but for now, let's ensure we have the necessary prerequisites in place:

### For Windows users :

`mantrachaind` prebuilt binaries areavailable for Linux and Mac based systems for the time being, So you’ll need to setup [WSL](https://learn.microsoft.com/en-us/windows/wsl/) to get it working over on Windows machines . Open your terminal as Administrator and run following command.

```powershell
wsl --install
```

This command will enable the features necessary to run WSL and install the Ubuntu distribution of Linux. Restart your machine and open WSL as admin for the initialization and you’ll all good to go. Please ensure that all steps are being followed in the WSL Environment. You can access WSL by running the following command in the terminal.

```jsx
wsl
```

## The Toolset

1. **Go**: We will require Go version v1.18 or higher to work with `mantrachaind`. You can easily set it up by following the [official documentation](https://golang.org/doc/install) or Run the following commands according to your OS.
    - Windows WSL and Linux Users :
    
    ```bash
    sudo apt update
    sudo apt install -y wget tar
    wget https://golang.org/dl/go1.22.5.linux-amd64.tar.gz
    sudo tar -C /usr/local -xzf go1.22.5.linux-amd64.tar.gz
    echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
    source ~/.profile
    ```
    
    - MacOS Users:
    
    ```bash
    brew update && brew install go
    echo 'export export GOPATH=$HOME/go' >> ~/.zshrc
    echo 'export GOROOT="$(brew --prefix golang)/libexec"' >> ~/.zshrc
    echo 'export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin' >> ~/.zshrc
    source ~/.zshrc
    ```
    
2. **Rust**: We already discussed that Rust is important, as it’s the primary language for `CosmWasm` development. Run the following command to setup [rustup](https://rustup.rs/) on your system.
    - Windows Users :
    Download and execute **rustup-init.exe** from [rustup.rs](https://rustup.rs/) or [rust-lang.org](https://www.rust-lang.org/tools/install). If requested, manually download and install Microsoft C++ Build Tools, from https://visualstudio.microsoft.com/visual-cpp-build-tools/ . Continue running **rustup-init.exe**, and proceed with the installation.
    - Linux or MacOS Users :
        
        ```powershell
        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
        source $HOME/.cargo/env
        ```
        
        ![23.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/23.webp?raw=true)
        
        
        After setting up Rust and Cargo (which manages and builds Rust code), you'll need two important tools:
        
        - `cargo-generate` is a project template tool - it's like a blueprint copier that helps you start new projects quickly by using pre-made project layouts.
        - `cargo-run-script` is a task runner - it helps you create and run quick commands for your project, just like how you can create shortcuts for common tasks in Node.js projects.
        
        To install these tools, run:
        
        ```jsx
        cargo install cargo-generate --features vendored-openssl
        cargo install cargo-run-script
        ```
        
        ![002.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/002.webp?raw=true)
        
3. **IDE:** We will need an code editor that supports Rust. [VSCode](https://code.visualstudio.com/) is a good option together with the [Rust Analyzer plugin](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer). Alternatively, another great option is [RustRover](https://www.jetbrains.com/rust/), Jetbrains’ IDE specifically designed for Rust development.
4. **Docker:** Docker is essential for setting up and running applications in isolated environments. You can install Docker by following the instructions on the [official Docker website](https://www.docker.com/) for your respective operating system. 
    - Windows Users: Activate the WSL integration in Docker Desktop settings.
5. **Git:** Git is a version control system that lets you track changes to your code, collaborate with others, and revert to previous versions if needed. It's like a time machine for your code!
    - **Download & Install:** Grab it from the official website: [git-scm.com](https://git-scm.com/) and follow the instructions.
6. **GitHub CLI:** The GitHub CLI allows you to interact with GitHub from the command line. This tool is not mandatory but it’s good to have. Follow these steps to set it up:
    - Install GitHub CLI by following the instructions from [here](https://github.com/cli/cli).
    - **Open your terminal**: Launch your preferred terminal application.
    - **Verify GitHub CLI installation**: Run `gh --version` to ensure you have successfully installed the GitHub CLI.
    - **Authenticate with GitHub**:
        - Run `gh auth login --web` in your terminal.
        - Choose your preferred protocol for Git operations (e.g., HTTPS).
        - Authenticate Git with your GitHub credentials by typing `Y`.
        - Copy the code displayed in your terminal.
        - Press Enter to open a browser window.
        - Paste the code and authorize Git by entering your GitHub password.
        
        **⚠️ Important**: Keep the terminal window open throughout the process.
            
    ![20.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/20.webp?raw=true)

**You did it!** Awesome, you are all set!! Good job! You have successfully installed Git and set up the GitHub CLI. You're now ready to move on to the next steps in the tutorial. Keep going!

## Installing WebAssembly target

Before you start developing smart contracts, we will need to ensure that we have the `wasm32` target installed. This target allows Rust to compile code to WebAssembly (WASM), which is necessary for deploying smart contracts on MANTRA Blockchain.

Follow these steps to set it up:

1. **Update Rust and Add the WASM32 Target**:
    
    ```bash
    rustup update stable
    rustup target add wasm32-unknown-unknown
    ```
    
2. **Verify the Target is Installed**:
    
    ```bash
    rustup target list --installed
    ```
    
    ![24.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/24.webp?raw=true)
    

The `wasm32-unknown-unknown` target allows Rust to compile code to WebAssembly. "wasm32" specifies the architecture, "unknown" indicates that there is no specific vendor, and "unknown" means no specific operating system, making the application more flexible.

## mantrachaind

**`mantrachaind`** is the backbone of the CosmWasm platform for the MANTRA DuKong Chain and it will be our main tool for development. We will be using this tool for everything from initializing configurations, managing keys, running the full node, and querying the blockchain.

Let’s download the pre-built binaries from [MANTRA GitHub Repo](https://github.com/MANTRA-Chain/mantrachain/releases/) and add it to PATH by running the following commands in your terminal. The following commands will create a new folder named *MANTRA,* downloads the binaries , unzip it and finally add it our PATH.

- Windows WSL and Linux Users :

```bash
mkdir -p ~/MANTRA
cd ~/MANTRA
curl -LO https://github.com/MANTRA-Chain/mantrachain/releases/download/v1.0.0/mantrachaind-1.0.0-linux-amd64.tar.gz
tar -xzvf mantrachaind-1.0.0-linux-amd64.tar.gz
chmod +x mantrachaind
echo 'export LD_LIBRARY_PATH=~/MANTRA:$LD_LIBRARY_PATH' >> ~/.bashrc
echo 'export PATH=~/MANTRA:$PATH' >> ~/.bashrc
source ~/.bashrc
```

- MacOS Users :
    - CLI Tool for Intel Chips
    
    ```bash
    mkdir -p ~/MANTRA
    cd ~/MANTRA
    curl -LO https://github.com/MANTRA-Chain/mantrachain/releases/download/v1.0.0/mantrachaind-1.0.0-darwin-amd64.tar.gz
    tar -xzvf mantrachaind-1.0.0-darwin-amd64.tar.gz
    chmod +x mantrachaind
    echo 'export LD_LIBRARY_PATH=~/MANTRA:$LD_LIBRARY_PATH' >> ~/.zshrc
    echo 'export PATH=~/MANTRA:$PATH' >> ~/.zshrc
    source ~/.zshrc
    ```
    
    - CLI Tool for Silicon chips (M1, M2...)
    
    ```bash
    mkdir -p ~/MANTRA
    cd ~/MANTRA
    curl -LO https://github.com/MANTRA-Chain/mantrachain/releases/download/v1.0.0/mantrachaind-1.0.0-darwin-arm64.tar.gz
    tar -xzvf mantrachaind-1.0.0-darwin-arm64.tar.gz
    chmod +x mantrachaind
    echo 'export LD_LIBRARY_PATH=~/MANTRA:$LD_LIBRARY_PATH' >> ~/.zshrc
    echo 'export PATH=~/MANTRA:$PATH' >> ~/.zshrc
    source ~/.zshrc
    ```
    

Now if you try executing it and get the following error, **then alone** we will need to install the CosmWasm library `libwasmvm.x86_64.so` .

![Screenshot_2024-07-29_151310.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/Screenshot_2024-07-29_151310.webp?raw=true)

If you are on a x86_64 system:

```bash
sudo wget -P /usr/lib https://github.com/CosmWasm/wasmvm/releases/download/v2.1.0/libwasmvm.x86_64.so
```

On arm64 (i.e. Apple silicon chips):

```bash
sudo wget -P /usr/lib https://github.com/CosmWasm/wasmvm/releases/download/v2.1.0/libwasmvm.aarch64.so
```

Now if we try to execute `mantrachaind` again , then we will be shown all commands that can be executed using it as shown below.

![5.1.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/5.1.webp?raw=true)

Finally we will need to install `jq` , a lightweight and flexible command-line JSON processor. It helps us to slice and filter and map and transform structured JSON data.

- Windows WSL and Linux Users :

```bash
sudo apt-get install jq
```

- MacOS Users :

```bash
brew install jq
```

With all of this out of the way, we can now quickly setup our development environment.

## Setting Up Environment Variables

Let’s dive into the setup process for `mantrachaind`. We’ll start by configuring the `mantrachaind` executable to interact with the DuKong network. This involves a few key steps: setting up environment variables, creating and managing wallets, and requesting tokens from the faucet. Each step is essential for ensuring that our development environment is correctly set up and ready for use.

### **Create a Configuration File**:

Create a new project folder, lets say `MantraChain` and then create a file called `mantrachaind-cli.env`.

**Note:** We will use this project for learning but we'll provide you the boilerplate alongside this file in the upcoming lessons.
Now, add the following content to the `mantrachaind-cli.env` file:

- For Windows WSL / Linux Users

```bash
export CHAIN_ID="mantra-dukong-1"
export TESTNET_NAME="mantra-dukong"
export DENOM="uom"
export BECH32_HRP="wasm"
export WASMD_VERSION="v0.53.0"
export CONFIG_DIR=".mantrachaind"
export BINARY="mantrachaind"
export COSMJS_VERSION="v0.28.1"
export GENESIS_URL="https://<location-to-be-provided>/config/genesis.json"
export RPC="https://rpc.dukong.mantrachain.io:443"
export FAUCET="https://faucet.dukong.mantrachain.io"
export NODE="--node $RPC"
export TXFLAG="--node https://rpc.dukong.mantrachain.io:443 --chain-id $CHAIN_ID --gas-prices 0.01$DENOM --gas auto --gas-adjustment 1.5"
```

- For MacOS Users

```bash
export CHAIN_ID="mantra-dukong-1"
export TESTNET_NAME="mantra-dukong"
export DENOM="uom"
export BECH32_HRP="wasm"
export WASMD_VERSION="v0.53.0"
export CONFIG_DIR=".mantrachaind"
export BINARY="mantrachaind"
export COSMJS_VERSION="v0.28.1"
export GENESIS_URL="https://<location-to-be-provided>/config/genesis.json"
export RPC="<https://rpc.dukong.mantrachain.io:443>"
export FAUCET="<https://faucet.dukong.mantrachain.io>"
export NODE=(--node $RPC)
export TXFLAG=($NODE --chain-id $CHAIN_ID --gas-prices 0.01$DENOM --gas auto --gas-adjustment 1.5)
```

Save the file and then source it so as to set the environment variables by running the following command:

```bash
source mantrachaind-cli.env
```

![5.2.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/5.2.webp?raw=true)

We’ll use these environment variables later to interact with the network.

## **Setup Wallet Addresses**:

Set up wallet addresses for storing tokens by running the following commands in your terminal.

```bash
mantrachaind keys add wallet
mantrachaind keys add wallet2
```

Running the command above will add two encrypted private keys to the `mantrachaind` keyring and display their attributes as follows:

![5.6.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/5.6.webp?raw=true)

**⚠️ Important**: Write down the mnemonic recovery phrase in a safe place. It is the only way to recover your account and connect our wallet to Keplr.

Take note of the 12 or 24-word mnemonic phrase associated with one of your existing wallets, be it either wallet or wallet2. This phrase will be used to import the wallet into Keplr, enabling a more user-friendly experience.

## Connecting Wallet to Keplr

**Step 1: Install Keplr Wallet Extension**

Install the Keplr Wallet extension compatible with your browser from  https://keplr.app/ .

**Step 2: Import Existing Wallet**

Import your existing wallet by selecting "Import an existing Wallet", choosing "Use Recovery phrase or recovery key", and pasting your 12 or 24-word mnemonic phrase.

**Step 3: Set Up Wallet**

Set up your wallet by adding a name and password.

![5.3.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/5.3.webp?raw=true)

**Step 4: Adding MANTRA Dukong Testnet to Keplr Wallet**

1. Navigate to the [MANTRA Chain Explorer](https://explorer.mantrachain.io/)

2. Amongst the network options in the dashboard, select `MANTRA-Dukong`

3. Access the Wallet Helper Tool:
   - Go to the `TOOLS` section
   - Look for "Wallet Helper Tool"

4. Configure the connection settings:
   - Network: Select `Testnet`
   - Chain: Choose `MANTRA-Dukong`
   - Wallet: Select `Keplr`

5. Click the "SUGGEST MANTRA-DUKONG TO KEPLR" button

6. In the Keplr wallet popup, review and approve the network addition

**Step 5: Configure Wallet Settings**

To enable MANTRA Testnet in your wallet interface:

1. Open your Keplr wallet extension

2. Click on the hamburger menu (☰) in your wallet

3. Select "Manage Chain Visibility"

4. In the search bar, type "MANTRA"

5. Look for "MANTRA Dukong Testnet" in the results

6. Check the box next to it to enable the network

![5.4.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/5.4.webp?raw=true)

You have now successfully integrated Keplr with your wallet, setting the stage for seamless interactions with your dApp in upcoming lessons.

## **Requesting Tokens**

You will need some tokens in your wallet address to interact with the network. To request testnet tokens:

- Head over to the [MANTRA Discord Server](https://discord.com/invite/gfks4TwAJV), Join and Verify your account.
- Navigate to `#dukong-faucet-role`Channel.
- Type `/request`.
- Enter and Submit Your Wallet Address (either wallet or wallet2).
- Receive Your Test Tokens.
- Note : Do note that if you have added funds to wallet2 then ensure to specify wallet2 when deploying the contract later in the lessons. We’ll add a reminder there as well so that you don’t miss it.

![5.5.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment/5.5.webp?raw=true)

By clicking on the “*Check them here*” hyperlink, you’ll be taken to the Dukong Mantra chain explorer, where you’ll be able to see the testnet tokens deposited in your account.

⚠️ Your Discord account age should be at least 14 days in order to be eligible for receiving the Testnet tokens.

## That’s a Wrap

Great job setting up `mantrachaind`, configuring your environment, and getting those test tokens! With everything in place, you’re now ready to take the next exciting step—deploying your very first smart contract on the Mantra Chain. Let’s get started and see what amazing things you can build!



https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/1.%20Introduction%20to%20CosmWasm/5.%20Setting%20Up%20the%20Development%20Environment.md

Setting Up the Development Environment

# Getting Started with Rust

Welcome back, developers! It's time to roll up your sleeves and get hands-on with Rust, the programming language that fuels the magic of CosmWasm. Remember, no prior Rust experience is required – we'll walk you through the essentials step by step. By the end of this lesson, you'll have a grasp of Rust's fundamental concepts, including variables, data types, printing output, and functions, along with practical coding examples to solidify your understanding.

Okay, let's get our hands dirty with Rust! We'll cover the essential syntax and project structure you'll need to start coding. Don't worry if you're new to Rust; we'll take it step by step. But first, let's set up our coding playground.

## Setting Up Your Rust Project

1. **Fire up your terminal:** We'll use our trusty command line to create our project directory and initialize a new Rust project using Cargo, Rust's package manager.
2. **Create a new project:** In your terminal, navigate to your desired workspace and run:

```solidity
cargo new rust_basics
cd rust_basics
```

This will create a new directory called `rust_basics` with the basic structure for a Rust project.

![55.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/55.webp?raw=true)

3. **Open in VS Code:** Open the `rust_basics` directory in VS Code. You should see a `src` directory containing a file called `main.rs`. This is where we'll write our Rust code. Notice that a “Hello, world!” code is already written in the `main.rs` file.

![56.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/56.webp?raw=true)

4. Lets update the code to print “Hello, MANTRA Chain!”, instead of “Hello, world!”. (Don’t forget to save the file after editing).
    
    ![57.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/57.webp?raw=true)
    
    This code defines a function called `main`, which is the entry point of any Rust program. Inside the function, we use the `println!` macro to print the message "Hello, MANTRA Chain!" to the console. We will see both functions and println in detail later in the lesson.
    
5. Now in the terminal of VS Code, execute the following command to run the code.

```solidity
cargo run
```

This will compile your code and, if there are no errors, execute it. You should see the following output:

```solidity
Hello, MANTRA Chain!
```
Here's the screenshot of the output.

![58.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/58.webp?raw=true)

Congratulations! You've just run your first Rust program. It might be a simple "Hello, MANTRA Chain!" example, but it's a significant step in your journey to becoming a CosmWasm developer. In the next sections, we'll explore more Rust fundamentals that will empower you to build powerful smart contracts on MANTRA Chain.

## Variables: Your Code's Storage Containers

In Rust, variables are like labeled boxes where you can store different types of information. Think of them as little containers that hold values, which can be numbers, text, or other kinds of data.

To create a variable, you use the `let` keyword, give it a name, and assign it a value:

```solidity
let message = "Hello, MANTRA Chain!";
```

Here, we've created a variable called `message` and stored the text "Hello, MANTRA Chain!" inside it.

Now, let's put this into action with a hands-on example in your Rust project:

1. **Open your `main.rs` file:** This is where we'll write our code.
2. **Declare a variable:** Add this line of code to your `main` function:

```solidity
let greeting = "Greetings from MANTRA Chain!";
```

3. **Print the variable:** Add this line to print the value of your variable:

```solidity
println!("{}", greeting);
```

`{}`:  This is a placeholder within the string. It tells Rust that you want to insert the value of a variable at this position in the output. In our example, we're inserting the value of the `greeting` variable.

4. Your complete `main.rs` file should now look like this:

```solidity
fn main() {
    let greeting = "Greetings from MANTRA Chain!";
    println!("{}", greeting); 
}
```

5. **Run your code:** Save the file and run the following command:

```solidity
cargo run
```

6. You should see "Greetings from MANTRA Chain!" printed in your terminal! You've successfully created a variable and used it in your Rust program.

![59.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/59.webp?raw=true)

**Let's see another example:**

```solidity
fn main() {
    let name = "Alice";
    let age = 30;
    println!("My name is {} and I am {} years old.", name, age);
}
```

1. **Variable Declaration:**
    - `let name = "Alice";`: This line creates a variable named `name` and assigns it the string value "Alice".
    - `let age = 30;`: This line creates another variable named `age` and assigns it the integer value 30.
2. **String Formatting with `println!`:**
    - `println!("My name is {} and I am {} years old.", name, age);`: This line uses the `println!` macro to print a formatted string to the console.
        - The string `"My name is {} and I am {} years old."` contains two curly brace placeholders `{}`. These placeholders act as markers where the values of the `name` and `age` variables will be inserted.
        - After the string, you see `, name, age`. This part provides the values to be inserted into the placeholders. The values are passed in the same order as the placeholders appear in the string.
3. When you run this code, it will produce the following output:

```solidity
My name is Alice and I am 30 years old.
```
Here's the screenshot of the output.

![60.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/60.webp?raw=true)

## Mutable vs. Immutable: Rust's Changeable and Unchangeable Values

In Rust, every variable has a superpower: it's either mutable or immutable.

**Immutable Variables:** These are the constants of Rust, the values that stay the same throughout your program. Once you set their value, it's fixed and cannot be changed.

For example, in our earlier example:

```solidity
let greeting = "Greetings from MANTRA Chain!";
```

The variable `greeting` is immutable. It will always hold the value "Greetings from MANTRA Chain!", and any attempt to change it would result in an error. This might seem restrictive, but it's a powerful feature that helps prevent accidental changes to important values.

![61.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/61.webp?raw=true)

**Mutable Variables:** These are the shape-shifters of the Rust world. They can change their value as your program runs, adapting to new information or situations.

To create a mutable variable, you simply add the `mut` keyword before the variable name:

```solidity
let mut count = 0;
count = 10; // This is allowed because 'count' is mutable
```

In this case, we first create a mutable variable called `count` and set its initial value to 0. Later, we can easily change its value to 10.

Try to print the value of count before and after update and see the output.

```solidity
fn main() {
    let mut count = 0;
    println!("First value = {}", count);
    count = 10; // This is allowed because 'count' is mutable
    println!("Update value = {}", count);
}
```
Here's the screenshot of the output.

![62.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust/62.webp?raw=true)

**Why Mutability Matters:**

Mutable variables are essential for creating dynamic programs that can respond to changes. In the context of smart contracts, mutability allows you to update the state of your contract based on user interactions or other events on the blockchain.

**Important Note:**

While mutability is powerful, it's important to use it carefully. In Rust, you need to explicitly declare a variable as mutable, which helps prevent accidental changes to values that should remain constant. This emphasis on explicitness is part of Rust's design philosophy, promoting safe and reliable code.

## That’s a Wrap

Woohoo! We've just taken our first steps into the exciting world of Rust programming. We've covered the essentials like variables, immutability, mutability, and even got our hands dirty by creating and running our first Rust program.

But hold onto your hats, because this is just the tip of the iceberg! Rust has a whole lot more to offer, and we'll be exploring its rich features in our next lesson. We'll delve into data types, functions, macros, and other powerful concepts that will empower you to create sophisticated CosmWasm smart contracts on the MANTRA Chain.

So, pat yourself on the back for a job well done, grab a cup of coffee (or your favorite beverage), and get ready for the next level of Rust programming adventure!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/2.%20Rust%20Fundamentals/1.%20Getting%20Started%20with%20Rust.md

Getting Started with Rust

# Data Types in Rust

Welcome back, Rust explorers! We've just scratched the surface of Rust's capabilities by getting acquainted with variables. Now, get ready to expand your toolbox with a deeper dive into Rust's data types. We'll explore how Rust handles numbers (integers, floats), text (characters), and other essential building blocks for your smart contracts. So, grab your coding gear and let's unlock the power of data in Rust!

## Need of Data Types

In the world of Rust, data types are the language your program uses to understand and manipulate information. Think of them as labels on boxes, telling Rust what's inside – whether it's numbers, text, or something more complex. What's cool is that Rust is smart enough to often figure out the type of data you're working with, even if you don't explicitly tell it. This is called *type inference*.

But why should we bother learning about data types if Rust is so clever?  Well, understanding data types is crucial for several reasons:

- **Logic and Reasoning:** Data types form the basis of how your program processes information. By understanding data types, you can reason about the flow of data, write more accurate logic, and avoid unexpected errors.
- **Language Understanding:** Data types are a fundamental part of Rust's syntax and semantics. Mastering them is essential for reading and writing Rust code effectively.
- **Function Input and Output:** Functions in Rust expect specific types of input and produce specific types of output. Understanding data types is crucial for defining functions correctly and ensuring they work as intended.
- **Contract State Management:** In the context of CosmWasm smart contracts, data types are used to define the structure of the data stored on the blockchain. This ensures that the data is consistent and can be manipulated safely.

So, even though Rust is smart, it's still important for us to be smart about data types. Let's dive in and explore the most common ones you'll encounter when building CosmWasm smart contracts!

## Deep dive into Data Types

Let’s take a look at some important data types in Rust.

### Integers (signed and unsigned): The Whole Numbers

Integers are used to represent whole numbers, both positive and negative. Rust has several integer types to choose from, each with a different size and range of values they can hold.

### Signed Integers: The Plus and Minus Crew (The Default)

Signed integers, as the name suggests, can represent both positive and negative numbers. When you declare an integer in Rust without specifying otherwise, it will be a signed integer. Rust provides several signed integer types, each with a different size and range:

| **Type** | **Size(bits)** | **Range** |
| --- | --- | --- |
| i8 | 8 | -128 to 127 |
| i16 | 16 | -32,768 to 32,767 |
| i32 | 32 | -2,147,483,648 to 2,147,483,647 |
| i64 | 64 | -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 |

### Unsigned Integers: The Positive Posse

Unsigned integers can only represent non-negative numbers (zero and positive values). To use an unsigned integer, you need to explicitly specify its type with a `u` prefix. Rust offers several unsigned integer types:

| **Type** | **Size(bits)** | **Range** |
| --- | --- | --- |
| u8 | 8 | 0 to 255 |
| u16 | 16 | 0 to 65,535 |
| u32 | 32 | 0 to 4,294,967,295 |
| u64 | 64 | 0 to 18,446,744,073,709,551,615 |

**Let's Code!**

1. Let's create a new file inside the `src` folder with the name `datatypes.rs`.
2. Add these lines inside the `datatypes.rs` file:

```solidity
pub fn main() {
    let num_tasks: u32 = 10;         // Unsigned 32-bit integer for task count
    let my_token_balance: u64 = 100000000;  // Unsigned 128-bit integer for token balance
    let profit_or_loss: i64 = -500;  // Signed 64-bit integer for profit/loss
    let default_int: i32 = -5;       // Signed 32-bit integer (i32 is inferred)

    // Print the values to the console:
    println!("Number of tasks: {}", num_tasks);           
    println!("My token balance: {}", my_token_balance); 
    println!("Profit/loss: {}", profit_or_loss);         
    println!("Default integer: {}", default_int);      
}
```

3. Let's go back to our `main.rs` and import the `datatypes.rs` module. When you run `cargo run`, the Rust compiler will execute `main.rs`, not `datatypes.rs`. Therefore, you need to ensure that `datatypes.rs` is included as part of `main.rs`.
    
    ```jsx
    mod datatypes;
    
    fn main() {
        datatypes::main();
    }
    ```
    
4. Run the code using our usual command `cargo run`, or in VS code you can simple click on the Run button on top right corner to the run the code.
    
    ![nft-mantra-c2 (1).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/2.%20Data%20Types%20in%20Rust/nft-mantra-c2_(1).webp?raw=true)
    

### Floating-Point Numbers: Handling Decimals in Rust

While integers are useful for representing whole numbers, floating-point numbers (or floats) are essential when you need to work with decimal values. Rust has two main types of floats: `f32` (single-precision) and `f64` (double-precision).

`f32` floats are smaller and faster to process but have less precision compared to `f64` floats, which offer more accuracy when dealing with decimal values. By default, Rust uses `f64` for floating-point numbers.

Floating-point numbers are widely used in financial applications like:

- **Token Prices:** Representing the price of a token in another currency (e.g., the price of OM in USD).
- **Interest Rates:** Calculating interest on loans or deposits.
- **Financial Calculations:** Performing complex calculations involving decimals.

**Let’s code**

1. Remove the previous code and add this code in `datatypes.rs` file.

```solidity
pub fn main() {
    let token_price: f64 = 23.55431273273917;        
    let token_price1: f32 = 23.55431273273917;         
    println!("f64 token price= {}", token_price);
    println!("f32 token price= {}", token_price1);
}
```

2. Run the code, you will get such an output:

```solidity
f64 token price= 23.55431273273917
f32 token price= 23.554314
```
Here's the screenshot of the output.

![nft-mantra-c2 (2).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/2.%20Data%20Types%20in%20Rust/nft-mantra-c2_(2).webp?raw=true)

3. **`token_price: f64`:** This declares a variable `token_price` as a double-precision float and assigns it a decimal value.
4. **`token_price1: f32`:** This declares a variable `token_price1` as a single-precision float and assigns it the same decimal value.

The `println!` statements then output the values of these variables.  Since `f64` has a higher precision, it will preserve more decimal places than `f32`, leading to a slightly different output for each variable.

This example showcases the importance of choosing the appropriate floating-point type based on the level of precision required for your calculations.

**Key Takeaway:** When high precision is crucial, especially in financial calculations, it's often advisable to use `f64` for its greater accuracy. However, `f32` can be used for scenarios where memory efficiency is a priority and slight precision loss is acceptable.

### Booleans: Rust's Truth Detectors

Booleans are the simplest of all data types in Rust. They can only have one of two values:

- `true` (representing "yes", "on", or "1")
- `false` (representing "no", "off", or "0")

Booleans are the backbone of logical operations and decision-making in your code. They allow you to create conditional statements and control the flow of your program based on whether certain conditions are met.

**Let’s see an example:**

1. Remove the previous code and add the below code in `datatypes.rs` (or you can create a new file, your choice🤓)

```solidity
pub fn main() {
    let is_rust_fun: bool = true; // Obviously!
    println!("Is Rust fun? {}", is_rust_fun);
}
```

2. Run your code and you should see:

```solidity
Is Rust fun? true
```
Here's the screenshot of the output.

![nft-mantra-c2 (3).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/2.%20Data%20Types%20in%20Rust/nft-mantra-c2_(3).webp?raw=true)

In your CosmWasm smart contracts, booleans will be crucial for implementing logic and decision-making. For example, you might use a boolean to track whether a transaction has been approved, a user is authorized, or a certain condition has been met.

Now that you've mastered booleans, you're well on your way to building more sophisticated and interactive dApps on MANTRA Chain!

### Characters: Rust's Alphabet, Beyond Just Letters

In Rust, the `char` data type is your toolbox for representing individual units of text. This means not only the letters you're used to (a, b, c, etc.) but also numbers, punctuation marks, and even symbols from different writing systems worldwide.

```solidity
let letter_m: char = 'M';       // An uppercase letter
let digit_1: char = '1';       // A number
let exclamation: char = '!';    // Punctuation
let chinese_character: char = '好'; // A character from another language
```

Notice how each character is enclosed in single quotes? That's how Rust knows you're talking about a single character, not a whole word or phrase.

**Let's Code!**

Remove the previous code and add the below code to your `datatype.rs` file and print them to the console:

```solidity
pub fn main() {
    let letter_a: char = 'a';
    let number_4: char = '4';
    let symbol_at: char = '@';
    println!("Letter: {}", letter_a);
    println!("Number: {}", number_4);
    println!("Symbol: {}", symbol_at);
}
```

Run your code and you should see:

```solidity
Letter: a
Number: 4
Symbol: @
```
Here's the screenshot of the output.

![nft-mantra-c2 (4).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/2.%20Data%20Types%20in%20Rust/nft-mantra-c2_(4).webp?raw=true)

Characters are the fundamental building blocks of text in Rust. They're not just letters, but any single symbol you can type on your keyboard (or beyond!). While you might work with longer pieces of text (strings) more often in your CosmWasm contracts, understanding how Rust handles individual characters is key for manipulating and processing textual data.

## Wrap Up

Congratulations! You've just unlocked the fundamental building blocks of Rust data: integers, floating-point numbers, booleans, and characters. You now understand how to declare variables, assign them values, and even make them mutable (changeable) if needed.  These basic data types will be your constant companions as you construct your CosmWasm masterpieces on MANTRA Chain.

But don't get too comfortable yet, because we're just getting warmed up! In the next lesson, we'll delve into the world of operators, giving you the power to manipulate and perform calculations like a pro. Get ready to wield these new tools and watch your Rust programming skills soar!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/2.%20Rust%20Fundamentals/2.%20Data%20Types%20in%20Rust.md

Data Types in Rust

# Operators in Rust: Unleashing Your Inner Mathematician (and Logician!)

Alright, MANTRA devs, buckle up because we're about to add some serious firepower to your coding arsenal! In the previous lesson, we explored the fundamental building blocks of data: integers, floats, booleans, and characters. Now, get ready to manipulate, transform, and combine these data types using Rust's powerful operators.

Think of operators as the verbs of the Rust language. They're the action words that tell your code what to *do* with your data. Want to add two numbers together? Check if a value is greater than another?  Flip the state of a boolean? Operators are your go-to tools.

## Types of Operators: A Toolbox for Data Manipulation

Rust offers a wide range of operators, but we'll focus on the ones most relevant for your CosmWasm journey:

1. **Arithmetic Operators:** For performing mathematical operations like addition, subtraction, multiplication, and division.
2. **Comparison Operators:** For comparing values and checking if they're equal, greater than, or less than each other.
3. **Logical Operators:** For combining boolean values (true/false) and creating complex logical expressions.
4. **Bitwise Operators:** For manipulating individual bits within integer values (we'll get to this in a later lesson).
5. **Assignment Operators:** For assigning values to variables.

### Arithmetic Operators

Arithmetic operators in Rust are the essential tools for performing basic mathematical calculations in your code. They work just like you learned in elementary school math class! Here's a quick rundown:

- `+` (Addition): Combines two values by adding them together.
- `-` (Subtraction): Finds the difference between two values.
- `*`(Multiplication): Calculates the product of two values.
- `/` (Division): Determines how many times one value fits into another.
- `%` (Modulo): Finds the remainder after division.

**Let’s see a coding example**

1. Create a new file in `src` folder with the name `operators.rs` 
2. Add the following code to the file:

```solidity
pub fn main() {
    let apples = 10;
    let oranges = 5;

    let total_fruit = apples + oranges;
    let remaining_apples = apples - oranges;
    let total_slices = apples * 4;
    let slices_per_person = total_slices / 2;
    let leftover_slices = total_slices % 3;

    println!("Total fruit: {}", total_fruit);
    println!("Remaining apples: {}", remaining_apples);
    println!("Total slices: {}", total_slices);
    println!("Slices per person: {}", slices_per_person);
    println!("Leftover slices: {}", leftover_slices);
}

```

1. Let's again go back to our `main.rs` and import the `operators.rs` module. This time we will comment out `datatypes.rs` as we are currently working on operators.
    
    ```jsx
    // mod datatypes; //we will comment out datatypes.rs as we are currently not using it in our code
    mod operators;
    
    fn main() {
        // datatypes::main(); // same goes for this line
        operators::main();
    }
    ```
    
    ![nft-mantra-c2 (5).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/3.%20Operators%20in%20Rust%20Unleashing%20Your%20Inner%20M/nft-mantra-c2_(5).webp?raw=true)
    

I think the code is simple enough, and you are smart enough, so moving ahead.

These operators work with various numeric data types (integers and floats). Just like in regular math, make sure the types of values you're operating on are compatible for the calculations.

With these operators, you can perform essential arithmetic operations within your CosmWasm smart contracts, such as calculating token balances, determining exchange rates, or even tracking the score of a game!

### Comparison Operators

In Rust, comparison operators are the judges of your code, determining whether one value is bigger, smaller, or equal to another. They're like referees in a sports match, making crucial decisions based on the rules of the game.

Here's a quick rundown of Rust's comparison operators:

- `==` (Equal to)
- `!=` (Not equal to)
- `>` (Greater than)
- `<` (Less than)
- `>=` (Greater than or equal to)
- `<=` (Less than or equal to)

These operators work with various data types, including numbers, characters, and even some custom types you might create in your smart contracts. Let's see how they work in action, remove the previous code and add this:

```solidity
pub fn main() {
    let x = 10;
    let y = 5;

    let is_equal = x == y;
    let is_not_equal = x != y;
    let is_greater = x > y;
    let is_less = x < y;
    let is_greater_or_equal = x >= y;
    let is_less_or_equal = x <= y;

    println!("x: {}, y: {}", x, y);
    println!("Is x equal to y? {}", is_equal);
    println!("Is x not equal to y? {}", is_not_equal);
    println!("Is x greater than y? {}", is_greater);
    println!("Is x less than y? {}", is_less);
    println!("Is x greater than or equal to y? {}", is_greater_or_equal);
    println!("Is x less than or equal to y? {}", is_less_or_equal);
}
```

Again, simple enough to understand correct?

When you run this code the output will be:

```solidity
x: 10, y: 5
Is x equal to y? false
Is x not equal to y? true
Is x greater than y? true
Is x less than y? false
Is x greater than or equal to y? true
Is x less than or equal to y? false
```

![nft-mantra-c2 (6).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/3.%20Operators%20in%20Rust%20Unleashing%20Your%20Inner%20M/nft-mantra-c2_(6).webp?raw=true)

This clearly shows the results of each comparison operation, demonstrating how you can use comparison operators in Rust to make decisions based on the relationships between values.

### Logical Operators

In Rust, logical operators are like the "and," "or," and "not" words in your mental decision-making process. They allow you to combine boolean values (`true` or `false`) to create more complex logical expressions.  Let's see how they work:

1. **Logical AND (`&&`)**:
    - This operator is like a strict bouncer at a club. It only lets you in if you meet *all* the criteria (both conditions are `true`).
    - For example: `true && true` evaluates to `true`, but `true && false` evaluates to `false`.
2. **Logical OR (`||`)**:
    - This operator is more relaxed. It lets you in if you meet *at least one* of the criteria (either condition is `true`).
    - For example: `true || false` evaluates to `true`, and `false || false` evaluates to `false`.
3. **Logical NOT (`!`)**:
    - This operator is a rebel. It simply flips the truth value of a boolean expression.
    - For example: `!true` is `false`, and `!false` is `true`.

**Code Example: Logical Playground**

```solidity
pub fn main() {
    let is_sunny = true;
    let water_is_warm = false;
    let no_sharks = true;

    let should_go_swimming = is_sunny && water_is_warm && no_sharks;
    let is_safe_to_swim = water_is_warm || no_sharks;
    let is_sunny_but_not_warm = is_sunny && !water_is_warm;

    println!("Should I go swimming? {}", should_go_swimming);        // false
    println!("Is it safe to swim? {}", is_safe_to_swim);             // true
    println!("Is it sunny but not warm? {}", is_sunny_but_not_warm);  // true
}

```

In this example, we combine our boolean variables (`is_sunny`, `water_is_warm`, `no_sharks`) using logical operators to determine if we should go swimming or if it's safe to swim. The `println!` statements display the results of these logical expressions.

![nft-mantra-c2 (7).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/3.%20Operators%20in%20Rust%20Unleashing%20Your%20Inner%20M/nft-mantra-c2_(7).webp?raw=true)

**Key Points:**

- Logical operators help you create complex conditions and make decisions in your code.
- They work with boolean values (`true` or `false`).
- Short-circuiting: In Rust, `&&` and `||` are short-circuiting operators. This means that if the left operand of `&&` is false, or the left operand of `||` is true, the right operand will not be evaluated, as the overall result is already determined.

By mastering logical operators, you'll be able to build smart contracts that can evaluate complex conditions and make intelligent decisions based on the state of the blockchain.

### Assignment Operators

In Rust, we've already seen the basic assignment operator `=`, which is like putting a value into a box (a variable). But Rust offers some handy shortcuts for common operations, known as compound assignment operators.

These operators combine arithmetic or bitwise operations with assignment, making your code more concise. Let's take a look:

| Operator | Meaning | Example |
| --- | --- | --- |
| += | Add and assign | x = x + 5 |
| -= | Subtract and assign | x = x - 3 |
| *= | Multiply and assign | x = x * 2 |
| /= | Divide and assign | x = x / 4 |
| %= | Modulo and assign | x = x % 7 |

**Coding example:**

```solidity
pub fn main() {
    let mut x = 10;
    x += 5;    // x is now 15 
    println!("x after adding 5: {}", x);
    x -= 3;    // x is now 12
    println!("x after subtracting 3: {}", x);
    x *= 2;    // x is now 24
    println!("x after multiplying by 2: {}", x);
    x /= 6;    // x is now 4
    println!("x after dividing by 6: {}", x);
    x %= 3;    // x is now 1
    println!("x after modulo 3: {}", x);
}
```

![nft-mantra-c2 (8).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/3.%20Operators%20in%20Rust%20Unleashing%20Your%20Inner%20M/nft-mantra-c2_(8).webp?raw=true)

### Wrap Up

Congratulations! You've just added some serious firepower to your Rust toolkit. We've covered the essential arithmetic and comparison operators for performing calculations and comparisons on your data. We've also explored logical and assignment operators, which allow you to combine boolean expressions and update variable values with ease.

Don't worry about mastering every single operator right now. We'll introduce more as they become relevant throughout our CosmWasm journey. In our next lesson, get ready to dive into the world of strings and discover how to manipulate text in your smart contracts like a pro!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/2.%20Rust%20Fundamentals/3.%20Operators%20in%20Rust%20Unleashing%20Your%20Inner%20Mathematician%20(and%20Logician!).md

Operators in Rust: Unleashing Your Inner Mathematician (and Logician!)

# Strings in Rust: Mastering Text and its Manipulation

Hey there, MANTRA coders! 

Ready to take your Rust skills to the next level? In our previous lesson, we tackled the operators in Rust. Now, let's dive deeper into the world of text manipulation with strings! We'll explore how to create, modify, and combine strings, giving you the power to handle textual data in your smart contracts with ease. Let’s get started!!

## Strings in Rust: Words, Phrases, and More

In the world of programming, we often need to work with text data – names, descriptions, addresses, and even entire documents. Rust provides two primary types for handling text: `String` and `&str`. Let's dive into their differences and how to use them effectively in your CosmWasm contracts.

**String: The Flexible Wordsmith**

In Rust, a `String` is a flexible way to store and manipulate text. It's like a blank document where you can add, remove, or change the words as needed.

But here's the twist: you need to tell Rust if you want that flexibility. If you don't want the text to change, just declare the string as usual. But if you might want to edit it later, add the magic word `mut` before the variable name. This gives you the power to change the string's contents whenever you like!

**Let’s code**

First, create a new file with the name `stringtutorial.rs` inside the `src` folder.

To create a `String`, you typically use the `from` function:

```solidity
pub fn main() {
    let mut mutable_greeting = String::from("Hello"); 
    mutable_greeting.push_str(", MANTRA Chain!"); // Add to the string
    println!("{}", mutable_greeting); // Output: "Hello, MANTRA Chain!"
}
```

Here, we start with "Hello" and then use the `push_str` function to append more text, creating a longer greeting. The `.push_str()` function is specifically designed to add a string slice to the end of an existing `String`.

Now go back to our `main.rs` and import the `stringtutorial.rs` module. 

```jsx
// mod datatypes;
// mod operators;
mod stringtutorial;

fn main() {
    // datatypes::main();
    // operators::main();
    stringtutorial::main();
}
```

![nft-mantra-c2 (9).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(9).webp?raw=true)

If we do not add `mut` keyword you will get following error:

![nft-mantra-c2 (10).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(10).webp?raw=true)

**&str: The Speedy Reference**

Think of a `&str` (pronounced "string slice") as a snapshot of a piece of text. It's a reference to a sequence of characters, often stored directly in your program's code or in a `String`. String slices are immutable, meaning you can't change the text they refer to, but they're super-fast to work with because they don't involve copying data.

If you've dabbled in languages like C or C++, you might find this concept familiar.  A `&str` is essentially Rust's version of a pointer to a string. Just like a pointer, a `&str` holds the memory address of where the actual text data begins, along with information about how long the string is.  However, unlike raw pointers in C/C++, Rust's references come with built-in safety guarantees, preventing you from accidentally accessing invalid memory locations or causing other nasty bugs.

Let's see how this works in code:

```solidity
pub fn main() {
    let my_slice: &str = "This is a string slice!";
    println!("{}", my_slice);
}
```

Run it, and you will get an output:

```solidity
This is a string slice!
```

Now, try to change it, it will not work.

```solidity
pub fn main() {
		let my_slice: &str = "This is a string slice!";
		my_slice.push_str("More text"); // Try to add this line, it will not work
		println!("{}", my_slice);
}
```

![nft-mantra-c2 (11).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(11).webp?raw=true)

Remember we cannot change the string they refer to, but we can always make them refer to a completely new string (provided you have used `mut` keyword). 

Remove the previous code and add the following code:

```solidity
pub fn main() {
    let mut my_slice: &str = "This is a string slice!";
    println!("{}", my_slice);
    my_slice = "Update value is string slice 2";
    println!("After change: {}", my_slice);
}
```

![nft-mantra-c2 (12).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(12).webp?raw=true)

Again we cannot change the value of original string &str was pointing to, but we can change where it is pointing to, if the variable is declared using `mut` keyword.

This distinction is important for understanding how string slices work in Rust. You'll often use them for efficiency when you only need to read or reference text without the need for modification.  If you do need to modify text, you'll typically use the `String` type instead.

## String Manipulation and Operations in Rust

Alright, you've mastered the fundamentals of strings in Rust.  Now, let's turn up the dial and unleash your inner wordsmith! In this section, we'll explore some essential techniques for manipulating and working with strings, giving you the skills to craft dynamic, expressive, and informative text within your CosmWasm smart contracts.

**Building and Combining Strings**

We already learned how to create strings using the `from` method in Rust:

```solidity
let my_string = String::from("Hello");
```

However, that is not the only way! Here are some common ways to create and combine strings:

- **The `format!` Macro:** This powerful tool allows you to insert variables and other values directly into your strings:

```solidity
pub fn main() {
    let name = "Alice";
    let age = 30;
    let message = format!("Hello, my name is {} and I am {} years old.", name, age);
    println!("{}", message); // Output: "Hello, my name is Alice and I am 30 years old."
}
```

![nft-mantra-c2 (13).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(13).webp?raw=true)

- **Concatenation (`+` operator):** For `String` types, you can concatenate (join) them together using the `+` operator.  The `+` operator for string concatenation expects a `&str` on the right-hand side. By using `&`, we create a reference to the `last_name` variable, effectively borrowing its value as a `&str` without having to create a new `String`. This avoids unnecessary copying of data and is more efficient.

```solidity
pub fn main() {
    let first_name = String::from("Alice");
    let last_name = String::from("Johnson");
    let full_name = first_name + " " + &last_name;
    println!("{}", full_name); // Output: "Alice Johnson"
}
```

![nft-mantra-c2 (14).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(14).webp?raw=true)

**String Operations:**

- **Length:**  Find out how long a string is using `.len()`:

```solidity
pub fn main() {
    let my_string = "Hello, MANTRA Chain!";
    let length = my_string.len();
    println!("The length of the string is: {}", length); //Output: "The length of the string is: 20"
}
```

![Screenshot 2024-08-26 at 2.28.45 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/Screenshot_2024-08-26_at_2.28.45_PM.webp?raw=true)

- **Indexing:**
    - Access individual characters within a string using indexing. Remember, indexing starts at 0 in Rust. Each character in the string has a corresponding position, or index, starting from zero.  So, the first character is at index 0, the second at index 1, and so on.
    - Rust strings are a bit more nuanced than in some other languages. They're not just simple arrays of characters, but rather a sequence of bytes encoded in UTF-8 .Each character in string might not necessarily be represented by a single byte, so we'll use the `.chars()` method to iterate over the characters correctly.
    
    Let's see how this works in code:
    
    ```solidity
    pub fn main() {
        let message = "Hello, MANTRA Chain!";
        let first_char = message.chars().nth(0).unwrap(); // Get the first character 'H'
        println!("The first character is: {}", first_char); // Outputs: 'H'
    
        let last_char = message.chars().nth(message.chars().count() - 1).unwrap(); // Get the last character '!'
        println!("The last character is: {}", last_char); // Outputs: '!'
    }
    ```
    
    In this example, `.chars()` creates an iterator that allows us to walk through the string character by character. The `nth(0)` method then retrieves the first character in the iterator, which is the letter 'H'.
    
    Similarly, `.chars().count()` finds total characters in the string, minus 1 to get last character.
    
    We use `.unwrap()` to get the character value assuming the index is valid. In a real-world senario, you'd want to handle the case where the index is invalid to prevent your program from panicking.
    
    ![nft-mantra-c2 (15).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(15).webp?raw=true)
    
    With this understanding of indexing, you can now precisely pinpoint individual characters within your strings. This will come in handy when you need to extract specific pieces of information or manipulate text in your CosmWasm smart contracts.
    
- **Slicing:**
    - Slicing in Rust is like using a pair of scissors to cut out a specific section of a string. It's a handy tool for extracting substrings, which are smaller portions of your original text. You can think of it as selecting a specific range of characters from a sentence or paragraph.
    - In Rust, we use square brackets `[]` and a range notation to specify the start and end indices of the slice we want to extract. The syntax looks like this:
    
    ```solidity
    &my_string[start..end]
    ```
    
    - Here, `start` is the index of the first character you want to include in the slice, and `end` is the index of the character *after* the last one you want to include. Remember, Rust's indexing starts at zero!
    
    **Let's see some slicing examples in action:**
    
    ```solidity
    pub fn main() {
        let message = "Hello, MANTRA Chain!";
    
        let hello_slice = &message[0..5];       // Extract "Hello"
        println!("{}", hello_slice);          // Output: Hello
    
        let mantra_slice = &message[7..13];     // Extract "MANTRA"
        println!("{}", mantra_slice);           // Output: MANTRA
    
        let chain_slice = &message[14..];        // Extract "Chain!"
        println!("{}", chain_slice);            // Output: Chain!
    
        let whole_string_slice = &message[..]; // Extract the entire string
        println!("{}", whole_string_slice);   // Output: Hello, MANTRA Chain!
    }
    ```
    
    ![nft-mantra-c2 (16).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Ma/nft-mantra-c2_(16).webp?raw=true)
    
    Let's break this down:
    
    1. We start with a string variable named message, containing the text "Hello, MANTRA Chain!".
    2. We then create several string slices:
        - `hello_slice` extracts the characters from index 0 up to (but not including) index 5, resulting in the string "Hello".
        - `mantra_slice` extracts the characters from index 7 up to (but not including) index 13, resulting in the string "MANTRA".
        - `chain_slice` extracts the characters from index 14 to the end of the string, resulting in the string "Chain!".
        - `whole_string_slice` extracts the entire string from the beginning (index 0) to the end.
    3. Finally, we print each of these slices to the console, demonstrating how we've successfully extracted different portions of the original string.

## Wrap up

Congratulations on leveling up your CosmWasm skills! This lesson empowered you to manipulate strings in Rust using both `String` and `&str` types. You learned how to create, modify, combine, and extract text, giving you the foundation to handle string data in your smart contracts.

Strings are crucial for communication in many applications, and we’ll continue to use and explore them throughout the development journey, this was just the tip of the iceberg to get you started with strings.

In the next lesson, we'll shift our focus from text to actions. We'll delve into the world of functions, which are the building blocks for organizing and executing your code's logic. Get ready to streamline your development process, improve code reusability, and create powerful smart contracts that can perform a wide range of tasks!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/2.%20Rust%20Fundamentals/4.%20Strings%20in%20Rust%20Mastering%20Text%20and%20its%20Manipulation.md

Strings in Rust: Mastering Text and its Manipulation

# Functions in Rust: Your Code's Action Heroes

Welcome back, adventurers! In our previous lessons, we conquered the world of strings and operators. Now, it's time to unleash the power of functions, the action heroes of your Rust code.

## What are Functions? Your Code's Superpowers

Imagine you're writing a recipe for a delicious MANTRA Chain-themed smoothie. You wouldn't write out the instructions for blending the ingredients every time you mention it in the recipe, right? Instead, you'd create a function called "blend_ingredients" and simply call it whenever needed.

Functions in Rust are similar. They're self-contained blocks of code that you can name and reuse throughout your program. They help you organize your code, make it more readable, and avoid repetition. Think of them as your code's superpowers, each with a specific purpose and ability.

### **The Anatomy of a Rust Function**

Let's dissect a basic Rust function:

```solidity
fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("MANTRA Developer"); // Calling the greet function
}
```

- `fn`: This keyword indicates that you're defining a function.
- `greet`: This is the name of the function. Choose descriptive names that reflect what the function does.
- `(name: &str)`: This is the function's parameter list. It specifies the type of data (`&str` for a string slice) that the function expects as input. In this case, the function `greet` expects a string slice named `name`.
- `{` and `}`: These curly braces enclose the function's body – the code that will be executed when the function is called.
- `println!("Hello, {}!", name);`: This line prints a greeting message to the console, inserting the value of the `name` parameter into the string using the `{}` placeholder.
- `fn main() {`: This is the `main` function, which is the entry point of your Rust program.
- `greet("MANTRA Developer");`: This line calls the `greet` function, passing the string "MANTRA Developer" as an argument for the `name` parameter.

### Functions with Return Values

Functions can also return values, just like mathematical functions.  To specify the return type, use an arrow (`->`) followed by the type:

```solidity
fn add(a: i32, b: i32) -> i32 {
    a + b // The result of the addition is returned
}

fn main() {
    let result = add(5, 3);
    println!("The sum is: {}", result); // Output: "The sum is: 8"
}
```

In this example, the `add` function takes two integers as input and returns their sum, which is then stored in the `result` variable and printed to the console.

 Let's break down this Rust code step-by-step:

**1. Function Definition (`add`):**

- `fn add(a: i32, b: i32) -> i32 {`:
    - `fn`: This keyword signifies the start of a function definition.
    - `add`: This is the name of the function (choose a descriptive name that reflects its purpose).
    - `(a: i32, b: i32)`: This is the parameter list. It defines the inputs the function expects. In this case, it takes two parameters named `a` and `b`, both of the `i32` type (32-bit signed integers).
    - `-> i32`: This indicates the return type of the function. It specifies that the function will return a value of type `i32`.
    - `{` and `}`: These curly braces enclose the function's body, the code that will be executed when the function is called.
    - `a + b`: This line is the function's body. It performs the addition of the two input values (`a` and `b`).
    - Implicit Return: In Rust, you don't need an explicit `return` statement if the last expression in a function body is a value. Rust automatically returns this value as the function's result.

**2. Main Function (`main`):**

- `fn main() {`: This defines the `main` function, which is the starting point of your Rust program's execution.
- `let result = add(5, 3);`: This line does two things:
    - It calls the `add` function, passing the values 5 and 3 as arguments for the `a` and `b` parameters, respectively.
    - It stores the returned value from the `add` function (which is 8) in a new variable called `result`.
- `println!("The sum is: {}", result);`: This line prints the following to the console:
    
    `The sum is: 8`
    

### Inbuilt and User-Defined Functions: Rust's Power Tools

Rust comes equipped with a set of built-in functions (like `println!` and `format!`) that simplify common tasks. However, the true power of Rust lies in creating your own *user-defined* functions, tailoring them to your specific needs. These functions encapsulate reusable blocks of code, making your programs more organized and efficient.

User-defined functions let you name a specific action (like `calculate_balance` or `verify_ownership`), define what kind of input it needs (parameters), and specify what it should produce as a result (return value). Remember our `add` function from earlier? That's a simple example of a user-defined function. It takes two numbers as input and returns their sum.

We'll dive deeper into creating and using functions as we build our to-do list dApp. This is just a taste of the power and flexibility that functions bring to Rust programming!

## Coding Challenge: Mastering Functions Through Geometry

Let's flex those Rust muscles and put your newfound knowledge of functions to work!  We're going to build a mini geometry calculator that can find the areas of different shapes. To make things interesting, we'll use each of these four ways to write functions

1. Function with a return value, but no input parameters.
2. Function with input parameters, but no return value.
3. Function with neither input parameters nor a return value.
4. Function with both input parameters and a return value.

Your task is to write a Rust program that calculates and displays the areas of:

- **Circle:** Given its radius.
- **Square:** Given its side length.
- **Rectangle:** Given its length and width.
- **Triangle:** Given its base and height.

You'll need to create a separate function for each shape, each adhering to one of the four function ways mentioned above.

**Let's Get Coding!**

Open your text editor or IDE and create a new Rust file (e.g., `area_of_shapes.rs`). Start by defining your functions, each following a different structure. Then, in your `main` function, call these functions with appropriate inputs to calculate and display the areas. Also don’t forget to update `main.rs` accordingly!

1. Add the function for calculating area of circle. This function will be of type: Function with Parameters and Return Type.

```solidity
fn area_of_circle(radius: f64) -> f64 {
    radius * radius * 3.14
}
```

1. **Function Definition (`area_of_circle`):**
    - `fn area_of_circle(radius: f64) -> f64 {`:
        - This line defines the function `area_of_circle`, which takes one parameter, `radius`, of type `f64` (double-precision floating-point number).
        - The `> f64` after the parameter list indicates that the function will return a value of type `f64`.
    - `radius * radius * 3.14`:
        - This is the function's body, where the calculation for the area of a circle is performed. It multiplies the radius by itself (squaring it) and then multiplies by the approximate value of pi (3.14).
2. Now lets call this function from main():

```solidity
pub fn main() {
    // Call the area_of_circle function
    let radius = 5.0;
    let circle_area = area_of_circle(radius);
    println!("Area of circle with radius {}: {}", radius, circle_area);
}
```

1. **Main Function (`main`):**
    - `let radius = 5.0;`: This line declares a variable `radius` and assigns it the value 5.0, representing the radius of the circle.
    - `let circle_area = area_of_circle(radius);`: This line calls the `area_of_circle` function, passing the value of `radius` as an argument. The function calculates the area and returns the result, which is then assigned to the variable `circle_area`.
    - `println!("Area of circle with radius {}: {}", radius, circle_area);`: This line prints a formatted message to the console, stating the radius of the circle and the calculated area. The `{}` placeholders are replaced by the values of the `radius` and `circle_area` variables, respectively.
        
        ![nft-mantra-c2 (17).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/5.%20Functions%20in%20Rust%20Your%20Code's%20Action%20Her/nft-mantra-c2_(17).webp?raw=true)
        
2. Add the function for calculating area of square. This function will be of type without parameters and without return type.

```solidity
// Function without parameters and without return type
fn area_of_square() {
    let side = 4;
    println!("Area of square: {}", side * side);
}
```

1. The `area_of_square` function calculates and prints the area of a square with a side length of 4. It does this without requiring any external input (no parameters) and without returning a value. 
2. The function first declares a variable `side` to store the side length, then calculates the area by squaring this value (`side * side`), and finally prints the result to the console using string interpolation. 
3. The absence of a return type (indicated by the empty parentheses after the function name) confirms that the function only performs an action (printing) and doesn't produce a value for further use.
4. Now call this function from main() by adding these lines after the existing code:

```solidity
 // Call the area_of_square function
    area_of_square();
```

![nft-mantra-c2 (18).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/5.%20Functions%20in%20Rust%20Your%20Code's%20Action%20Her/nft-mantra-c2_(18).webp?raw=true)

1. Add the function for calculating area of rectangle. This function will be of type with parameters and without return type.

```solidity
// Function with parameters, without return type
fn area_of_rectangle(length: i64, width: i64) {
    println!("Area of rectangle: {}", length * width);
}
```

1. This function takes two input parameters, `length` and `width` (both of type `i64`), representing the dimensions of a rectangle.
2. It calculates and directly prints the area of the rectangle to the console without returning any value.
3. Now call this function from main() by adding these lines after the existing code:

```solidity
// Call the area_of_rectangle function
    area_of_rectangle(10, 6);
```

![nft-mantra-c2 (19).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/5.%20Functions%20in%20Rust%20Your%20Code's%20Action%20Her/nft-mantra-c2_(19).webp?raw=true)

1. Finally, add the function for calculating area of triangle. This function will be of type without parameters and with return type.

```solidity
// Function without parameters and with return type
fn area_of_triangle() -> f64 {
    let length = 7.0; // Made these floats to match return type
    let base = 15.0;
    length * base * 0.5 
}
```

1. This function takes no input parameters, but it returns the area of a triangle as a `f64` floating-point value.
2. While the function doesn't take any input for customization, it internally defines fixed values for the length (7.0) and base (15.0). These values are used to calculate the area using the formula `0.5 * length * base`. The calculated area is then returned as a `f64` value.
3. Now call this function from main() by adding these lines after the existing code:

```solidity
    // Call the area_of_triangle function
    let triangle_area = area_of_triangle();
    println!("Area of triangle: {}", triangle_area);
```

1. The final code will be:

```solidity
// Function with parameters and with return type
fn area_of_circle(radius: f64) -> f64 {
    radius * radius * 3.14
}

// Function without parameters and without return type
fn area_of_square() {
    let side = 4;
    println!("Area of square: {}", side * side);
}

// Function with parameters, without return type
fn area_of_rectangle(length: i64, width: i64) {
    println!("Area of rectangle: {}", length * width);
}

// Function without parameters and with return type
fn area_of_triangle() -> f64 {
    let length = 7.0;
    let base = 15.0;
    length * base * 0.5 
}

fn main() {
    // Call the area_of_circle function
    let radius = 5.0;
    let circle_area = area_of_circle(radius);
    println!("Area of circle with radius {}: {}", 
    radius, circle_area);

    // Call the area_of_square function
    area_of_square();

    // Call the area_of_rectangle function
    area_of_rectangle(10, 6);

    // Call the area_of_triangle function
    let triangle_area = area_of_triangle();
    println!("Area of triangle: {}", triangle_area);
}

```

![nft-mantra-c2 (20).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/2.%20Rust%20Fundamentals/5.%20Functions%20in%20Rust%20Your%20Code's%20Action%20Her/nft-mantra-c2_(20).webp?raw=true)

## Wrap Up

Fantastic! In this lesson, we've leveled up your Rust skills by diving into the world of functions. You've learned how to define and call different types of functions, from those with parameters and return values to those without.  You've seen how functions can make your code more organized, reusable, and easier to understand. Plus, you've had the chance to practice these concepts through hands-on coding examples, flexing your newfound Rust muscles.

But we're not stopping there! In the next lesson, we'll tackle another powerful tool in the Rust arsenal: structs. Think of structs as blueprints for creating complex data structures that can hold multiple pieces of information together. They're essential for building sophisticated CosmWasm smart contracts, and we'll show you how to use them to model your data in a clear and efficient way. So, get ready to expand your Rust knowledge even further and take another step towards building awesome dApps on MANTRA Chain!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/2.%20Rust%20Fundamentals/5.%20Functions%20in%20Rust%3A%20Your%20Code's%20Action%20Heroes.md

Functions in Rust: Your Code's Action Heroes

# Structs in Rust: Building Blocks for Your Data

Welcome back, Rust adventurers! You've mastered the art of working with individual data types like integers, strings, and booleans, and you've even learned how to command your code with functions. Now, get ready to take your Rust skills to the next level as we explore the power of structs.

Think of structs as blueprints for building custom data structures. They're like containers that can hold multiple pieces of related information together, making your code more organized, expressive, and efficient.  In the world of CosmWasm smart contracts, structs are essential for modeling complex data, such as token information, user profiles, or even the entire state of your application.

## Struct Basics: What, Why, and How

A struct is a user-defined data type that lets you group together multiple fields, each with its own name and type. It's like a form with labelled fields, where each field can hold a different type of information.

Here's the basic syntax for defining a struct:

```solidity
struct NameOfStruct {
    field1_name: field1_type,
    field2_name: field2_type,
    // ...more fields...
}
```

Let's say you're building a dApp for managing a library of books. You could create a `Book` struct to represent each book:

```solidity
struct Book {
    title: String,
    author: String,
    year_published: u16,
    is_available: bool,
}
```

In this struct, we have four fields:

- `title`: A `String` to store the book's title.
- `author`: A `String` to store the author's name.
- `year_published`: A `u16` (unsigned 16-bit integer) to store the year the book was published.
- `is_available`: A `bool` to indicate whether the book is currently available for borrowing.

### Creating and Using Structs

1. To create an instance of a struct, you use the following syntax:

```solidity
let my_book = Book {
    title: String::from("The Hitchhiker's Guide to the Galaxy"),
    author: String::from("Douglas Adams"),
    year_published: 1979,
    is_available: true,
};
```

1. Once you've created a struct instance, you can access its fields using `dot` notation:

```solidity
println!("Title: {}", my_book.title); 
// Output: "Title: The Hitchhiker's Guide to the Galaxy"
```

2. Let’s write the complete code, first create a new file in `src` folder with the name `struct_example.rs`.
3. Add the following code in `struct_example.rs` file

```solidity
// Define the Book struct
struct Book {
    title: String,
    author: String,
    year_published: u16,
    is_available: bool,
}

pub fn main() {
    // Create an instance of the Book struct
    let my_book = Book {
        title: String::from("The Hitchhiker's Guide to the Galaxy"),
        author: String::from("Douglas Adams"),
        year_published: 1979,
        is_available: true,
    };
    println!("Book title: {}" ,my_book.title);
    println!("Book author: {}",my_book.author);
    println!("Book was published in the year: {}", my_book.year_published);
    println!("Is the book {}, available for borrowing? {}", my_book.title, my_book.is_available);
}

```

![nft-mantra-c2 (21).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/1.%20Structs%20in%20Rust%20Building%20Blocks%20for%20Your/nft-mantra-c2_(21).webp?raw=true)

4. **Structure Definition:** The code starts by defining a struct named `Book`. This struct serves as a blueprint for creating book objects. It outlines the specific information each book object will contain:
    - `title`: The title of the book, stored as a `String` (a sequence of characters).
    - `author`: The author of the book, also stored as a `String`.
    - `year_published`: The year the book was published, stored as a `u16` (unsigned 16-bit integer).
    - `is_available`: A boolean value (`bool`) that indicates whether the book is available for borrowing (`true`) or not (`false`).
5. **Creating a `Book` Instance:** Inside `main`, the line `let my_book = Book { ... };` creates a new book object named `my_book`. The curly braces `{}` are used to initialize the fields of the struct:
    - `title`: Set to "The Hitchhiker's Guide to the Galaxy".
    - `author`: Set to "Douglas Adams".
    - `year_published`: Set to 1979.
    - `is_available`: Set to `true`.
6. **Accessing Fields:**
    - `println!("Book title: {}" ,my_book.title);` accesses the book's title and prints it to the console.
    - `println!("Book author: {}",my_book.author);` accesses the book's author and prints it to the console.
    - `println!("Book was published in the year: {}", my_book.year_published);` accesses the book's year_published and prints it to the console.
    - `println!("Is the book {}, available for borrowing? {}", my_book.title, my_book.is_available);` accesses the book's title and is_available properties, and prints both to the console. The values are accessed using dot notation (e.g., `my_book.title`).

## Coding Challenge: The Token Tracker

Now it's your turn to create a struct and write some code!

**Your Task:**

Your mission is to build a program that defines a `Token` struct to represent a cryptocurrency token. Your `Token` struct should have the following fields:

- `name`: The name of the token (`String`)
- `symbol`: The token's ticker symbol (`String`)
- `total_supply`: The total number of tokens in existence (`u64`)
- `price`: The current price of one token (`f64`)

After you've defined your struct, write a function called `print_token_info` that takes a `Token` as input and prints all the information about it to the console. Then, create an instance of the `Token` struct in your `main` function with details about your favorite cryptocurrency (Bitcoin, Ethereum, OM, etc.), and call `print_token_info` to display those details.

We hope you have tried it on your own. 

**Let’s see the code and explanation:**

1. Create a file under src called `token_info.rs` and next define the token struct:

```solidity
struct Token {
    name: String,
    symbol: String,
    total_supply: u64,
    price: f64,
}
```

- We create a struct called `Token` to represent a cryptocurrency token.
    - Each `Token` will have four fields to store its information:
        - `name`: The full name of the token (e.g., "Bitcoin").
        - `symbol`: The token's ticker symbol (e.g., "BTC").
        - `total_supply`: The total number of tokens in existence.
        - `price`: The current market price of one token.
2. Create the `print_token_info` function:

```solidity
fn print_token_info(token: &Token) {
    println!("Token Name: {}", token.name);
    println!("Token Symbol: {}", token.symbol);
    println!("Total Supply: {}", token.total_supply);
    println!("Current Price: ${:.2}", token.price); // Display price with 2 decimal places
}
```

- This function takes a reference to a `Token` instance as input (`token: &Token`).
- It then uses `println!` statements to neatly display each field of the token: its `name`, `symbol`, `total_supply`, and `price`.
- Notice the use of the `:.2` formatting specifier in the price output to display only two decimal places.
3. Create a token instance in the `main` function:

```solidity
pub fn main() {
    let my_favorite_token = Token {
        name: String::from("Ethereum"),
        symbol: String::from("ETH"),
        total_supply: 120_230_000, // Approximate current supply as of Jul 2024
        price: 3266.52,        // Example price in USD
    };

    // Call the print_token_info function
    print_token_info(&my_favorite_token);
}
```

- We create a `Token` instance named `my_favorite_token` and initialize its fields with the data for Ethereum.
- We then call the `print_token_info` function, passing the `my_favorite_token` instance as an argument (using the `&` to pass a reference).
4. Here is the complete code and don’t forget to add it to `main.rs`:

```solidity
struct Token {
    name: String,
    symbol: String,
    total_supply: u64,
    price: f64,
}

fn print_token_info(token: &Token) {
    println!("Token Name: {}", token.name);
    println!("Token Symbol: {}", token.symbol);
    println!("Total Supply: {}", token.total_supply);
    println!("Current Price: ${:.2}", token.price); // Display price with 2 decimal places
}

pub fn main() {
    let my_favorite_token = Token {
        name: String::from("Ethereum"),
        symbol: String::from("ETH"),
        total_supply: 120_230_000, // Approximate current supply as of Jul 2024
        price: 3266.52,        // Example price in USD
    };

    // Call the print_token_info function
    print_token_info(&my_favorite_token);
}
```

5. The output is:

```solidity
Token Name: Ethereum
Token Symbol: ETH
Total Supply: 120230000
Current Price: $3266.52
```

![nft-mantra-c2 (22).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/1.%20Structs%20in%20Rust%20Building%20Blocks%20for%20Your/nft-mantra-c2_(22).webp?raw=true)

## Wrap Up

Congratulations! You've just unlocked the basics of creating custom data structures in Rust with structs. We've seen how structs can bundle related data together, creating a blueprint for organizing information in your code. Think of them as handy containers for keeping your data neat and tidy.

But this is just the beginning! In our next lesson, we'll dive deeper into methods and traits in Rust, exploring more advanced patterns and use cases. This will help you create more flexible, reusable, and expressive code for your decentralized applications on the MANTRA Chain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/3.%20Building%20Blocks%20of%20Rust/1.%20Structs%20in%20Rust%20Building%20Blocks%20for%20Your.md

Structs in Rust: Building Blocks for Your Data

# Methods and Traits in Rust

Welcome back, Rust adventurers! You've mastered the art of working with individual data types and functions, and now it's time to level up your skills even further! In this lesson, we'll explore two powerful concepts that will enhance your ability to create custom data types and define shared behavior: structs and traits.  Structs are like blueprints for building complex data structures, while traits are like contracts that define how different types should behave.

By the end of this lesson, you'll be able to create custom structs with multiple fields and functions, making your code more organized, reusable, and expressive. And with traits, you'll learn how to define shared behavior for different types, paving the way for building more flexible and powerful applications. So, get ready to elevate your Rust expertise and take another step towards building awesome dApps on MANTRA Chain!

## Methods: Actions for Your Structs

Alright, now that you've mastered the art of creating structs, it's time to give them some superpowers! In Rust, we can add functions directly to our structs, turning them into objects that can *do* things, not just *hold* data. These special functions are called methods, and they're the key to making your code more organized, reusable, and expressive.

Imagine you're building a car in code. You wouldn't just create a blueprint with the car's attributes (like color, model, and year); you'd also want to define what the car can *do* (like accelerate, brake, or turn). In Rust, methods are like the car's actions – they're functions that are specifically associated with a particular struct.

They're defined within an `impl` (implementation) block for the struct, and they have special access to the struct's data fields.

Here's the basic syntax for defining a method:

```solidity
impl NameOfStruct {
    fn method_name(&self, other_parameters) -> return_type {
        // Code that the method executes
    }
}
```

- `impl`: This keyword indicates that you're providing an implementation for a type (in this case, a struct).
- `NameOfStruct`: The name of the struct you're adding methods to.
- `fn method_name(&self, other_parameters) -> return_type`:
    - `fn`: This keyword indicates a function definition.
    - `method_name`: A descriptive name for your method.
    - `(&self, other_parameters)`: The parameter list. The first parameter is always `&self`, which is a reference to the struct instance itself. You can add other parameters after `&self` if needed.
    - `-> return_type`: This specifies the data type that the method returns (if any).

**Coding Example**

1. Let’s create a new file in `src` folder with the name `method_example.rs`.
2. Let's create a `Rectangle` struct and add some methods to it:

```solidity
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // Method to calculate the area of a rectangle
    fn area(&self) -> u32 {
        self.width * self.height 
    }

    // Method to check if a rectangle is a square
    fn is_square(&self) -> bool {
        self.width == self.height
    }
}
```

3. In this example:
    - The `area` method takes `&self` (a reference to the Rectangle instance) and calculates the area by multiplying the width and height. It then returns the area as a `u32` integer.
    - The `is_square` method also takes `&self` and returns a `bool` (true if the rectangle is a square, false otherwise).
4. Now let's use these methods in our `main` function:

```solidity
pub fn main() {
    let my_rect = Rectangle { width: 5, height: 10 };
    let area = my_rect.area();
    println!("The area of the rectangle is: {}", area); // Output: 50
    println!("Is it a square? {}", my_rect.is_square()); // Output: false
}
```

![nft-mantra-c2 (23).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/2.%20Methods%20and%20Traits%20in%20Rust/nft-mantra-c2_(23).webp?raw=true)

By calling the methods using dot notation (`.area()` and `.is_square()`), we can perform operations specific to our `Rectangle` struct in a clean and intuitive way.

## Traits in Rust: Contracts for Behavior

In Rust, a trait is like a contract that defines a set of behaviors a type must implement.  It's a way of saying, "If you want to be considered this kind of thing, you need to be able to do these specific actions."

### Why Traits?

Traits are a powerful tool for abstraction and code reuse in Rust. They allow you to:

- **Define shared behavior:** Group together common functionality that different types might share.
- **Enable polymorphism:** Write generic code that can work with multiple types that implement the same trait.
- **Enforce constraints:** Ensure that types used in certain contexts adhere to specific requirements.

### Defining a Trait

Here's the basic syntax for defining a trait:

```solidity
trait TraitName {
    fn method_signature1(&self, arg1: Type1, arg2: Type2) -> ReturnType;
    fn method_signature2(&self); // Methods can also have no arguments or return values
    // ...more methods...
}
```

Let's define a trait for a shape:

```solidity
trait Shape {
    fn area(&self) -> f64; // Method to calculate the area
    fn name(&self) -> &str; // Method to return the name of the shape
}
```

This `Shape` trait requires any type that implements it to have two methods:

- `area`: Calculates the area of the shape and returns it as an `f64` floating-point number.
- `name`: Returns the name of the shape as a string slice (`&str`).

### Implementing a Trait

To make a type (like a struct) conform to a trait, you need to implement its methods within an `impl` block:

```solidity
struct Circle {
    radius: f64,
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius 
    }

    fn name(&self) -> &str {
        "circle"
    }
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }

    fn name(&self) -> &str {
        "rectangle"
    }
}
```

**Explanation:**

- These two structs define different shapes:
    - `Circle`: Represents a circle with a `radius` property.
    - `Rectangle`: Represents a rectangle with `width` and `height` properties.

```solidity
impl Shape for Circle { ... }
impl Shape for Rectangle { ... }
```

- These blocks of code are where we actually teach each shape how to fulfill the `Shape` contract. We do this by providing specific implementations for the `area` and `name` methods within each struct's context.
- Let's break down the Circle implementation:
    - `fn area(&self) -> f64 { ... }`: This function calculates the area of a circle (pi * radius * radius) and returns it as an `f64`.
    - `std::f64::consts::PI` is the way you access the value of pi from the Rust standard library.  It's a double-precision floating-point number, which makes it suitable for accurate calculations involving circles in the `area` method.
    - We can add `use std::f64::consts::PI;` in the beginning to directly use `PI` in calculation.
    - `fn name(&self) -> &str { ... }`: This function simply returns the string "circle" as the name of the shape.
- **Rectangle's implementation is similar:**
    - `fn area(&self) -> f64 { ... }`: This function calculates the area of a rectangle (width * height) and returns it as an `f64`.
    - `fn name(&self) -> &str { ... }`: This function returns the string "rectangle".

**Completing the code:**

- Create a new file with the name `trait_example.rs` and add the following code:

```solidity
use std::f64::consts::PI;

trait Shape {
    fn area(&self) -> f64;
    fn name(&self) -> &str;
}

struct Circle {
    radius: f64,
}

impl Shape for Circle {
    fn area(&self) -> f64 {
        PI * self.radius * self.radius
    }

    fn name(&self) -> &str {
        "circle"
    }
}

struct Rectangle {
    width: f64,
    height: f64,
}

impl Shape for Rectangle {
    fn area(&self) -> f64 {
        self.width * self.height
    }

    fn name(&self) -> &str {
        "rectangle"
    }
}

pub fn main() {
    let my_circle = Circle { radius: 5.0 };
    let my_rectangle = Rectangle { width: 4.0, height: 6.0 };

    println!(
        "The area of the {} is {}",
        my_circle.name(),
        my_circle.area()
    );
    println!(
        "The area of the {} is {}",
        my_rectangle.name(),
        my_rectangle.area()
    );
}
```

![nft-mantra-c2 (24).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/2.%20Methods%20and%20Traits%20in%20Rust/nft-mantra-c2_(24).webp?raw=true)

This showcases how the `Shape` trait allows us to write code that can work with multiple different types of shapes (circles and rectangles in this case) in a uniform way. This is the power of polymorphism in action!

## Wrap Up

Congratulations! You've just unlocked the power of methods and traits in Rust. You now know how to give your structs special abilities with methods, and how to define shared behavior across different types using traits. This makes your code more versatile and prepares you to build sophisticated smart contracts that can handle complex logic and data structures.

Get ready to level up your organization skills in the next lesson, where we'll dive into modules. You'll learn how to create clean, well-structured code that's easy to understand, reuse, and maintain. Think of it as giving your CosmWasm projects a neat and tidy workspace – essential for tackling larger-scale dApps on MANTRA Chain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/3.%20Building%20Blocks%20of%20Rust/2.%20Methods%20and%20Traits%20in%20Rust.md

Methods and Traits in Rust

# Modules in Rust: Organize Your Code Like a Pro

Welcome back, Rust architects! In our last lesson, we gave superpowers to our data structures with methods and traits. Now, let's zoom out and look at the bigger picture of organizing our Rust code.  As our CosmWasm smart contracts become more sophisticated, keeping our code neat and tidy is crucial for maintainability and collaboration. 

That's where modules come in – think of them as the dividers in your toolbox, keeping your wrenches separate from your screwdrivers. In this lesson, we'll learn how to use modules to create well-structured, reusable code that's ready to tackle complex dApps on MANTRA Chain.

## What are Modules? Your Code's Filing Cabinets

Imagine a library with thousands of books scattered randomly on the floor. Finding the right book would be a nightmare! That's why libraries use a system of shelves, sections, and catalogs to organize their collection.

Modules in Rust serve a similar purpose. They are like virtual "filing cabinets" that allow you to group related code together, making it easier to navigate, manage, and reuse.

## Why Use Modules?

Modules provide several key benefits:

- **Organization:** They help you break down your code into smaller, more manageable chunks. Instead of having one giant file, you can split your code into multiple modules, each responsible for a specific part of your program's functionality.
- **Encapsulation:** Modules can control the visibility of items (functions, structs, etc.) within them. You can make some items public (accessible from outside the module) and others private (accessible only within the module). This helps you hide implementation details and create clean interfaces for interacting with your code.
- **Namespace Management:** Modules prevent naming collisions. You can have functions or structs with the same name in different modules without any conflicts.
- **Reusability:** By grouping related code into modules, you can easily reuse them in other parts of your project or even in different projects altogether.

## Creating and Using Modules

Creating a module in Rust is as simple as using the `mod` keyword followed by the module name. 

Add the below code in a new file under `src` folder with the name `module_example.rs` and import it to `main.rs`:

```solidity
mod utils {  // Declare a module named 'utils'
    pub fn double(x: i32) -> i32 {  // A public function within the module
        x * 2
    }
}

pub fn main() {
    let result = utils::double(5);  // Accessing the 'double' function from the 'utils' module
    println!("Double of 5 is: {}", result);
}

```

![nft-mantra-c2 (25).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/3.%20Modules%20in%20Rust%20Organize%20Your%20Code%20Like%20/nft-mantra-c2_(25).webp?raw=true)

In this example, we've created a module called `utils` that contains a single function, `double`.  The `pub` keyword before the function definition makes it accessible from outside the module. In the `main` function, we use the `::` (double colon) operator to access the `double` function from the `utils` module.

### Multiple Files and Nested Modules

You can also split your modules into separate files and even create nested modules.  For example, you could have a `math` folder that contains submodules for `basis` which will be have basic math functions at:

```solidity
src/
├── module_example/ //the directory name should be same as module_example file
│   ├── math.rs 
├── area_of_shapes.rs
├── datatypes.rs
├── main.rs
├── method_example.rs
├── module_example.rs
├── operators.rs
├── stringtutorial.rs
├── struct_example.rs
├── token_info.rs
├── trait_example.rs
```

Let's take what we've learned about modules and put it into practice. We'll create a mini-library for mathematical operations and use it within our main Rust file.

1. **Step 1: Create a New Module**
- In your `rust_basics` project, create a new file named `math.rs` under `src/module_example` directory.
- Inside `math.rs`, define a module called basics:

```solidity
pub mod basics { // Declare a public module named 'basics'
    pub fn add(a: i32, b: i32) -> i32 { // Public function within the module
        a + b
    }

    fn subtract(a: i32, b: i32) -> i32 { // Private function within the module
        a - b
    }
}
```

- We have two functions in this module
    - add - which is public as it will be used in the main file.
    - subtract - it is private so it will only be used within the file math_utils.rs
    
2. **Step 2: Import and Use the Module**
- Open your `module_example.rs` file.
- At the beginning of the file, add the following line to import the `math` module:

```solidity
mod math; // Import the module math to access the submodule basics.rs
```

- `mod math;` brings the entire contents of the `math.rs` file into the scope of your `module_example` file as a module.
- This module acts as a container for the nested `basics` submodule, allowing you to control the visibility of its functions.
- Now, let’s complete the main():

```solidity
mod math;

pub fn main() {
    // Accessing the public function
    let sum = math::basics::add(5, 3); 
    println!("5 + 3 = {}", sum); // Output: 5 + 3 = 8

    // Trying to access the private function directly (will result in an error)
    //let diff = math::basics::subtract(5, 3);  // Error: function is private
}
```

**Explanation:**

- **Module Import:** The line `mod math;` brings the `basics` module (defined in the `math.rs` file) into the scope of this file.
- **Accessing Public Function:** The line `let sum = math::basics::add(5, 3);` calls the `add` function from the `basics` module within `math`. The double colon `::` is used to navigate the module hierarchy. Since `add` is marked `pub`, it's accessible from outside the module.
- **Trying to Access Private Function:** The commented-out line `//let diff = math::basics::subtract(5, 3);` attempts to call the `subtract` function directly, but it results in a compilation error because `subtract` is private and can only be used within the `math` module itself.

**Important Note:** In a real project, you might choose to make some functions private if they are meant to be internal helper functions used by other functions within the module. This helps to encapsulate your code and prevent accidental misuse from outside the module.

### `use` keyword

In Rust, the `use` keyword is used to bring external items (like functions, structs, enums, modules, or traits) from other crates (libraries) or modules into the current scope. This makes it more convenient to reference those items in your code without having to write their full paths every time.

For instance, in the previous example where we had a `basics` module defined within a file called `math.rs`, you could import the `add` function like this:

```solidity
use math::basics::add;
```

This allows you to use the `add` function directly in your code, like so:

```solidity
let sum = add(5, 3);
```

![nft-mantra-c2 (26).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/3.%20Modules%20in%20Rust%20Organize%20Your%20Code%20Like%20/nft-mantra-c2_(26).webp?raw=true)

This is really helpful when you need to use a function multiple times in the file.

## Wrap Up

In this lesson, you learned how to harness the power of modules in Rust to organize your code, improve readability, and promote reusability. We'll delve deeper into the use of modules and the `use` keyword throughout this course, especially when building our to-do dApp.  But for now, just remember that modules are your friends when it comes to organizing your Rust code and making it more modular and reusable!

In the next lesson we will learning about Enums and Options, these will be used a lot when we are developing our dApp later in the course.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/3.%20Building%20Blocks%20of%20Rust/3.%20Modules%20in%20Rust%20Organize%20Your%20Code%20Like%20.md

Modules in Rust: Organize Your Code Like a Pro

# Enums & Options: Rust's Power-Ups

Welcome back, Rust adventurers! You've mastered a lot of rust fundamentals topics and more.  Now, let's explore some advanced data structures that will make your Rust code more expressive, flexible, and powerful. In this lesson, we'll tackle:

- **Enums:** Representing a fixed set of choices.
- **Options:** Handling the possibility of missing values.

By the end of this lesson, you'll be equipped with a wider range of tools to model complex data and handle different scenarios in your CosmWasm smart contracts.

## Enums: Rust's Master of Disguise

In the programming world, sometimes you need to represent a set of distinct, pre-defined options. Imagine a traffic light – it can only be red, yellow, or green. You wouldn't want to store its state as a number (1, 2, or 3) because it's not immediately clear what those numbers mean. This is where enums shine!

**Enums as Categorical Types**

Enums, short for enumerations, are a way to define a custom type with a limited set of named values.  Think of them as multiple-choice answers for your code, where each choice has a specific meaning.

**Example: Coffee Sizes (with Debug powers!)**

Let's create an enum representing different coffee sizes, but this time, we'll give it the ability to tell us about itself for debugging purposes:

```solidity
#[derive(Debug)]  // This is new! It allows us to print the enum easily.
enum CoffeeSize {
    Small,
    Medium,
    Large,
}
```

In this example:

- **`CoffeeSize`:** The name of our custom enum type.
- **`Small`, `Medium`, `Large`:** The *variants* (possible values) of the `CoffeeSize` type. Each variant is like a label with a specific meaning.
- **`#[derive(Debug)]`:** This special line of code tells Rust to automatically add some behind-the-scenes code to our enum. This extra code will let us easily print the enum's value for debugging.

**Using Enums**

Once you've defined an enum, you can create variables of that type and assign them one of the variants:

```solidity
fn main() {
    // Declare a variable of type CoffeeSize and assign it the Medium variant
    let my_order: CoffeeSize = CoffeeSize::Medium;
    
    // Print the value of the variable 
    println!("Your order is: {:?}", my_order);
}
```

(Try it on your own in VS code, you know what to do correct?).

Let's break this down:

1. `let my_order: CoffeeSize = CoffeeSize::Medium;`: We create a variable named `my_order`, tell Rust it's of type `CoffeeSize`, and assign it the value `CoffeeSize::Medium`. Think of it like ordering a medium coffee.
2. `println!("Your order is: {:?}", my_order);`: We use `println!` to show us what's inside the `my_order` variable.
    - The `"{:?}"` is a special format specifier. It tells Rust to use the `Debug` implementation for `CoffeeSize` to print a user-friendly representation of the value.
    - More technically,  `#[derive(Debug)]` tells Rust to automatically generate an implementation for the `Debug` trait, which allows us to print the enum value using `{:?}` in the `println!` macro.
    - Without deriving `Debug`, we wouldn't be able to print the enum value directly. Instead, we'd need to implement the `Display` trait or use a match statement to convert the enum to a string.
    - By deriving `Debug`, we can easily inspect and print our enum values, making debugging and logging easier.

**Matching on Enums**

Rust's `match` expression is a powerful way to work with enums. It allows you to perform different actions depending on the specific variant of the enum value:

```solidity
fn main() {
    let my_order: CoffeeSize = CoffeeSize::Large;

    match my_order {
        CoffeeSize::Small => println!("Enjoy your small coffee!"),
        CoffeeSize::Medium => println!("Enjoy your medium coffee!"),
        CoffeeSize::Large => println!("Enjoy your large coffee!"),
    }
}
```

In this example, the `match` expression checks the value of `my_order` and prints a different message depending on whether it's `Small`, `Medium`, or `Large`.

In the world of CosmWasm, you'll encounter enums frequently in smart contracts, especially for representing different types of messages, queries, or contract states.

**Enum Variants with Data: Pairing Enums with Structs**

Enums can also carry data associated with each variant, often in combination with structs.  This is particularly useful when you need to represent different types of objects that share a common trait.

Let's illustrate how enums and structs can work together using a to-do list example:

**Scenario:** Imagine you're building a to-do list app where tasks can have different priorities. You want to represent these priorities in a structured way within your code.

Create a file in `src` folder with the name `enum_example.rs` and add the following code:

```solidity
#[derive(Debug)] // Add derive for Debug to allow printing
enum Priority {
    High,
    Medium,
    Low,
}

struct ToDoItem {
    task: String,
    priority: Priority, 
}

pub fn main() {
    // Create a to-do item with high priority
    let task1 = ToDoItem {
        task: String::from("Complete CosmWasm tutorial"),
        priority: Priority::High,
    };

    // Create a to-do item with medium priority
    let task2 = ToDoItem {
        task: String::from("Learn about MANTRA Chain"),
        priority: Priority::Medium,
    };

    // Create a to-do item with low priority to avoid the warning
    let task3 = ToDoItem {
        task: String::from("Take a break"),
        priority: Priority::Low,
    };

    // Print information about the tasks
    println!("Task 1: {}, Priority: {:?}", task1.task, task1.priority);
    println!("Task 2: {}, Priority: {:?}", task2.task, task2.priority);
    println!("Task 3: {}, Priority: {:?}", task3.task, task3.priority); 

    // Example of matching on the priority
    match task1.priority {
        Priority::High => println!("This task is urgent!"),
        Priority::Medium => println!("This task is important."),
        Priority::Low => println!("This task can wait."),
    }
}

```

![nft-mantra-c2 (27).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/4.%20Enums%20&%20Options%20Rust's%20Power-Ups/nft-mantra-c2_(27).webp?raw=true)

**Code Explanation:**

1. **Deriving the `Debug` Trait:**
    - `#[derive(Debug)]`: This line is like giving your `Priority` enum a special ability to be printed out in a readable format. In Rust, certain traits (like `Debug`) need to be implemented for types if you want to print their values directly. The `derive` attribute tells Rust to automatically generate the code for implementing `Debug` for our enum, so we don't have to write it ourselves.
2. **Defining the `Priority` Enum:**
    - `enum Priority { High, Medium, Low }`: This defines an enum called `Priority`, representing the different priority levels a task can have. Enums are like multiple-choice options, where each value (`High`, `Medium`, `Low`) is a distinct possibility.
3. **Defining the `ToDoItem` Struct:**
    - `struct ToDoItem { task: String, priority: Priority }`: This defines a struct called `ToDoItem` to represent a single task in our to-do list. Each task has two parts:
        - `task`: A `String` to store the description of the task.
        - `priority`: A field of type `Priority`, indicating the priority level of the task (one of the values from our enum).
4. **Creating `ToDoItem` Instances:**
    - `let task1 = ToDoItem { ... }`: This line creates a new instance of the `ToDoItem` struct.
        - `task: String::from("Complete CosmWasm tutorial")`: We initialize the `task` field with a description of the task.
        - `priority: Priority::High`: We set the `priority` field to the `High` variant of the `Priority` enum.
    - The code then creates two more instances, `task2` and `task3`, with different descriptions and priority levels.
5. **Printing Task Information:**
    - `println!("Task 1: {}, Priority: {:?}", task1.task, task1.priority);`:
        - This line prints a message that includes the task description (`task1.task`) and priority (`task1.priority`).
        - The `{:?}` format specifier is used because the `priority` field is an enum, and we've derived the `Debug` trait for it. This tells Rust to print the enum variant's name (e.g., "High").
    - The code then prints similar messages for `task2` and `task3`.
6. **Matching on Priority (Decision Making):**
    - `match task1.priority { ... }`: This is a `match` expression, which is a powerful control flow construct in Rust. It allows you to perform different actions depending on the value of an expression (in this case, `task1.priority`).
    - `Priority::High => println!("This task is urgent!")`: If the priority is `High`, it prints "This task is urgent!".
    - `Priority::Medium => println!("This task is important.")`: If the priority is `Medium`, it prints "This task is important."
    - `Priority::Low => println!("This task can wait.")`: If the priority is `Low`, it prints "This task can wait."

## Options: Embracing the "Maybe" in Your Rust Code

In the world of code, sometimes you encounter situations where a value might be there... or it might not be. Maybe you're searching for a user in a database, but they don't exist. Or perhaps you're trying to calculate a result, but the input data is invalid. How do you handle these "maybe" situations without causing your program to crash and burn?

Enter the Option type, Rust's elegant solution for representing optional values.

**The Option Enum: A Box with a Surprise (or Not!)**

Think of `Option` as a box that either contains a gift or is empty. You don't know which one it is until you open it.  In Rust, the `Option` type is an enum with two variants:

- `Some(T)`: This variant represents a box with a present inside. The `T` can be any type of data – a number, a string, a struct, you name it!
- `None`: This variant represents an empty box, indicating that there's no value.

```solidity
enum Option<T> {
    Some(T),
    None,
}
```

- **`Option<T>`:** This is a generic enum, meaning it can hold a value of any type (`T`).
- **`Some(T)`:** This variant indicates that there's a value present, and it holds the actual value of type `T`.
- **`None`:** This variant indicates that there's no value.

## Example: Optional Bonus Points

Let's say you're writing a program to calculate a student's grade, and there's a possibility of bonus points. We can model this uncertainty using an `Option`:

```solidity
pub fn main() {
    let base_score: i32 = 85;
    let bonus_points: Option<i32> = Some(5); // Some bonus points
    //let bonus_points: Option<i32> = None;   // No bonus points

    let final_score = match bonus_points {
        Some(points) => base_score + points,
        None => base_score,
    };

    println!("Final Score: {}", final_score);
}

```

![nft-mantra-c2 (28).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/4.%20Enums%20&%20Options%20Rust's%20Power-Ups/nft-mantra-c2_(28).webp?raw=true)

In this example:

- We create a variable `bonus_points` of type `Option<i32>`. It is initialized to `Some(5)`, indicating that the student earned 5 bonus points.
- The `match` expression checks whether `bonus_points` is `Some` or `None`.
    - If it's `Some`, we extract the value using `points` and add it to the `base_score`.
    - If it's `None`, we simply use the `base_score` as the final score.
- If we uncomment the line  `let bonus_points: Option<i32> = None;`, the output would be "Final Score: 85" since there are no bonus points.

**Why Options are Essential:**

By using the `Option` type, you make your code more robust and prevent errors caused by trying to access values that might not exist.  It's a core concept in Rust's error handling strategy and helps you write safer, more reliable code.

## Wrap Up

Congratulations! You've just expanded your Rust knowledge with enums and options. With enums, you've learned how to represent choices or categories within your code, making it clearer and more expressive. And with options, you've gained the ability to gracefully handle scenarios where values might be missing, enhancing the robustness of your applications.

But hold on tight, because we're not done yet! In our next adventure, we'll tackle two more powerful tools in Rust's arsenal: vectors and attributes. Vectors will allow you to store and manipulate collections of data, while attributes will let you add special metadata to your code. Get ready to level up your Rust toolkit once again!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/3.%20Building%20Blocks%20of%20Rust/4.%20Enums%20%26%20Options%20Rust's%20Power-Ups.md

Enums & Options: Rust's Power-Ups

# Vectors & Attributes:  Power Up Your Rust Data Arsenal

Get ready to level up your Rust programming skills, CosmWasm explorers! In this lesson, we're adding two powerful tools to your toolbox: vectors and attributes.

## Vectors: Your Dynamic Data Collection

Imagine you're hosting a party, but you're not sure how many guests are coming.  You need a way to store everyone's names, but you don't want to limit yourself to a fixed number of invitations. That's where vectors come in handy!

Vectors (`Vec<T>`) in Rust are like expandable lists.  You can add or remove items as needed, making them perfect for storing collections of data that might change over time.

**Creating and Manipulating Vectors**

Creating a vector is a breeze:

```solidity
// Create an empty vector to hold i32 integers
let mut numbers: Vec<i32> = Vec::new(); 
```

Adding elements is just as easy:

```solidity
numbers.push(10);
numbers.push(25);
numbers.push(5);
```

You can also access elements by their index (remember, indexing starts at zero):

```solidity
let second_number = numbers[1]; 
println!("The second number is: {}", second_number); // Output: 25
```

Combining all:

```solidity
fn main()
{
		// Create an empty vector to hold i32 integers
    let mut numbers: Vec<i32> = Vec::new(); 
    numbers.push(10);
    numbers.push(25);
    numbers.push(5);
    let second_number = numbers[1]; 
    println!("The second number is: {}", second_number); // Output: 25
}
```

### Vectors Within Structs: Storing Multiple Items

Let's say you want to create a struct called `ShoppingList` that can hold multiple items. You can use a vector inside the struct to store this list, let’s create a file called `vector_example.rs` and add this code:

```solidity
struct ShoppingListItem {
    name: String,
    quantity: u32,
}

struct ShoppingList {
    items: Vec<ShoppingListItem>,
}

pub fn main() {
    let mut my_list = ShoppingList { items: Vec::new() };

    my_list.items.push(ShoppingListItem {
        name: String::from("Apples"),
        quantity: 3,
    });
    my_list.items.push(ShoppingListItem {
        name: String::from("Bananas"),
        quantity: 5,
    });
    my_list.items.push(ShoppingListItem {
        name: String::from("Milk"),
        quantity: 1,
    });

    for item in my_list.items {
        println!("{}: {}", item.name, item.quantity);
    }
}
```

Let's break down this code step-by-step to understand how structs and vectors work together to create a shopping list:

**Defining the Building Blocks**

- `struct ShoppingListItem { name: String, quantity: u32 }`:
    - This defines a structure called `ShoppingListItem` to represent individual items on your list.
    - Each item has two properties:
        - `name`: A `String` to store the name of the item (e.g., "Apples").
        - `quantity`: A `u32` (unsigned 32-bit integer) to store the quantity of the item (e.g., 3).
- `struct ShoppingList { items: Vec<ShoppingListItem> }`:
    - This defines a structure called `ShoppingList`.
    - It has one field:
        - `items`: A `Vec<ShoppingListItem>`, which is a vector (a resizable list) to store multiple `ShoppingListItem` structures. Think of this as a way to hold all the items in your shopping cart.

**2. Creating an Empty Shopping List**

- `let mut my_list = ShoppingList { items: Vec::new() };`:
    - This creates a mutable variable `my_list` that holds a `ShoppingList` instance.
    - Inside the curly braces `{}`, we're initializing the `items` field with a new, empty vector. We use `Vec::new()` to create an empty vector of `ShoppingListItem` structs. The `mut` keyword makes the `my_list` variable mutable, allowing us to add items to it later.

**3. Adding Items to the Shopping List**

- `my_list.items.push(ShoppingListItem { ... });`: This line adds a new item to the `my_list.items` vector. The `push` method is used to add an element to the end of a vector.
    - Inside the `push` method, we create a new `ShoppingListItem` struct, providing values for its `name` and `quantity` fields.
    - The code repeats this `push` operation three times to add "Apples," "Bananas," and "Milk" to the shopping list.

**4. Iterating and Printing the Shopping List**

- `for item in my_list.items { ... }`: This is a `for` loop that iterates over each item in the `my_list.items` vector.
    - For each iteration, the `item` variable holds a reference to a single `ShoppingListItem` struct within the vector.
    - `println!("{}: {}", item.name, item.quantity);`: This line prints the name and quantity of the current `item` to the console.

**Output:**

When you run the code, the output will be:

```solidity
Apples: 3
Bananas: 5
Milk: 1
```

This demonstrates how to create a struct to represent a collection of items using a vector. We are using this to create a shopping list where each item is represented as another struct (`ShoppingListItem`).

![nft-mantra-c2 (29).png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/3.%20Building%20Blocks%20of%20Rust/5.%20Vectors%20&%20Attributes%20Power%20Up%20Your%20Rust%20/nft-mantra-c2_(29).webp?raw=true)

## Attributes: Your Code's Secret Messages

Ever left yourself a sticky note reminder on your computer screen? Or maybe flagged an important email? Attributes in Rust are kind of like that - they're little notes you attach to your code to give it special instructions or add metadata. While not part of the core logic of your program, attributes can be incredibly useful for various tasks, from customizing how your code compiles to integrating with external libraries.

### Anatomy of an Attribute

In Rust, attributes look like this:

```solidity
#[attribute_name(optional_parameters)]
```

They start with a `#` followed by square brackets `[]`, containing the attribute name and, optionally, some parameters.  You place them right before the item you want to annotate (like a function, struct, or module).

### Why Use Attributes?

Attributes serve different purposes, depending on their name and parameters.  They can:

- **Provide configuration for the compiler:** Tell the compiler how to optimize code, enable language features, or even conditionally compile certain parts of your code.
- **Add information for documentation tools:** Help generate better documentation for your code.
- **Enable features from external libraries:** Integrate your code with external libraries that use attributes for configuration or code generation.
- **Customize tests and benchmarks:** Control how your tests are run or how your code is benchmarked.

### Example: Serde for Serialization and Deserialization

One of the most common attributes you'll encounter in CosmWasm is `#[derive(Serialize, Deserialize)]`. This attribute, provided by the `serde` library, is used for serializing and deserializing data structures.

**Serialization: Turning Data into a Portable Format**

- Think of serialization as packing your belongings into a suitcase for a trip. You take your clothes, toiletries, and other items and neatly arrange them into a compact, portable format that can be easily transported.
- In programming, serialization does something similar for data. It takes a complex data structure (like a struct or enum) and converts it into a format that can be easily stored or transmitted over a network.  Common serialization formats include JSON, XML, and binary formats.

**Deserialization: Unpacking Your Data**

- Now, imagine arriving at your destination and unpacking your suitcase. You take out your belongings and restore them to their original form so you can use them.
- Deserialization is the reverse of serialization. It takes the serialized data (e.g., a JSON string) and converts it back into its original data structure (like a struct or enum) so that you can work with it in your code.

**Why Serialization and Deserialization Matter for Smart Contracts**

In the world of blockchain and smart contracts, serialization and deserialization are crucial for several reasons:

- Smart contracts need to store their state (data) on the blockchain. Serialization allows them to store complex data structures in a compact and efficient format.
- Smart contracts communicate with each other and with external clients by sending messages. These messages typically contain data that needs to be serialized before being sent and deserialized upon receipt.
- Different blockchain platforms and applications might use different serialization formats. By using a common format like JSON, you can ensure that your smart contracts can interact with a wider range of systems and tools.

Rust provides a powerful library called Serde for handling serialization and deserialization. It works with a variety of data formats, including JSON, and makes it incredibly easy to convert your Rust data structures to and from these formats.

We will see its implementation and usage while creating our to-do dApp in later lessons.

## Wrap Up

Fantastic! You've just expanded your Rust knowledge with a powerful new data structure: vectors! You now understand how to create dynamic lists that can grow and shrink as needed, making it easy to manage collections of data within your CosmWasm smart contracts. You've also been introduced to the concept of attributes, those handy little annotations that can add metadata to your code and unlock new functionality.

In the next lesson, we'll shift gears. Get ready for a hands-on demonstration where we'll compile and deploy our first "Hello World" CosmWasm smart contract on the MANTRA testnet. This exciting step will bring your code to life on the blockchain, opening the door to a world of possibilities!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/3.%20Building%20Blocks%20of%20Rust/5.%20Vectors%20%26%20Attributes%20Power%20Up%20Your%20Rust.md

Vectors & Attributes: Power Up Your Rust Data Arsenal

# Hello World in CosmWasm

Welcome back people! In this lesson, we'll learn to compile, optimize and deploy a *Hello World* smart contract on the MANTRA testnet. We'll cover essential steps like updating configurations, optimizing our contract for minimal gas costs, and uploading our code to the blockchain. Plus, We'll instantiate our contract and interact with it to see our message stored in the contract's storage. So let’s not waste any more time and get our Smart contract onto the Mantra Dukong Testnet.

## **Project Files & Setup**

We've prepared a simple Hello World smart contract for you to use throughout this tutorial. To access the project files, please fork the repository using the following command:

```bash
gh repo fork https://github.com/0xmetaschool/building-on-MANTRA-chain.git --clone 
cd building-on-MANTRA-chain
```

### Setting Up Environment Variables

⚠️ **Important Note**: After cloning the repository, you'll find a template `mantrachaind-cli.env` file. Instead of using this template directly, you should:

1. Open your own `mantrachaind-cli.env` file from Lesson 5
2. Copy its contents
3. Paste these contents to replace everything in the template file

**Critical Check**: This ensures that your environment variables, particularly:
- The `NODE` configuration
- The `TXFLAG` parameters

match exactly with your system-specific settings from Lesson 5.

To activate these settings, source the environment file in your terminal:
```bash
source mantrachaind-cli.env
```

Your project structure would as shown below 

![16.1.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm/16.1.webp?raw=true)

Alright then, Let’s compile our smart by running the following command.

```bash
cargo build --target wasm32-unknown-unknown --release
```

![16.2.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm/16.2.webp?raw=true)

Once the compilation is completed, you will be able to see the newly generated `hello_world.wasm` at `target/wasm32-unknown-unknown/release` directory. This is the file we will deploying to testnet, but first we need to optimize it. 

## Optimizing our Contract

When it comes to smart contracts, smaller is better. The smaller your contract's binary size, the less you'll pay in gas costs. And who doesn't love saving money? Luckily, there's a tool that can help you shrink your contract's size without sacrificing performance.

### Rust-Optimizer

We will be using the [rust-optimizer](https://github.com/CosmWasm/rust-optimizer) tool to optimize our production code. This tool produces reproducible builds of CosmWasm smart contracts, enabling third-party verification of the contract's authenticity. 

⚠️ Just make sure you've got Docker up and running on your machine before you get started. Run the following command to optimize our code.

Run one of the following commands based on your system to optimize the code:

### For Linux and Windows WSL Users:

```bash
docker run --rm -v "$(pwd)":/code \
  --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \
  --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
  cosmwasm/optimizer:0.16.0
```

### For Mac Users:

- **Intel-based Mac**:
    
    ```bash
    docker run --rm -v "$(pwd)":/code \
      --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \
      --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
      cosmwasm/optimizer:0.16.0
    ```
    
- **Apple Silicon (M1/M2) Mac**:
    
    ```bash
    docker run --rm -v "$(pwd)":/code \
      --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \
      --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
      cosmwasm/optimizer-arm64:0.16.0
    ```
    

Once you run the optimizer, you will find the `hello_world.wasm` file for your smart contract deployment under `/artifacts`.

![16.3.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm/16.3.webp?raw=true)

### Note for Windows WSL Users

If you are using Windows, follow these steps to ensure Docker works properly with WSL:

1. Open Docker Desktop
2. Navigate to **Settings**
3. From the **General** tab, select **Use WSL 2 based engine**
    - If you have installed Docker Desktop on a system that supports WSL 2, this option is turned on by default
4. Select **Apply & Restart**

### Troubleshooting

- Make sure Docker is running before executing the command
- Ensure you're in the correct directory containing your smart contract code
- For Windows WSL users, make sure WSL 2 is properly configured and Docker Desktop is set to use the WSL 2 based engine

Now before we go in and deploy our smart contract, if you want to see the list of codes that was uploaded to the network previously then run the following command to do so.

```bash
mantrachaind query wasm list-code $NODE
```

## Deploying the Contract

Run the following command to upload your wasm binary to the network and store the response in the `RES` variable. This response will contain the unique Code ID of your uploaded binary.

Note : If you have funded the wallet named under ‘wallet2’ then do specify “wallet2” instead of “wallet” in the following commands. 

```bash
RES=$(mantrachaind tx wasm store artifacts/hello_world.wasm --from wallet $TXFLAG -y --output json)
echo $RES
```

Next, use the `RES` variable to request the transaction hash, stored as `TX_HASH`. With this hash, you can then fetch the full transaction details, including events, and extract the `CODE_ID` from the response.

```bash
TX_HASH=$(echo $RES | jq -r .txhash)
CODE_ID=$(mantrachaind query tx $TX_HASH $NODE -o json | jq -r '.events[] | select(.type == "store_code") | .attributes[] | select(.key == "code_id") | .value')
echo $CODE_ID
```

![16.4.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm/16.4.webp?raw=true)

You can see the list of contracts instantiated using the particular Code Id using `mantrachaind` we had already setup and running the following command : 

```bash
mantrachaind query wasm list-contract-by-code $CODE_ID $NODE --output json
```

The response will be an empty list as shown below, This is because we have not instantiated any contract yet.

```bash
{"contracts":[],"pagination":{"next_key":null,"total":"0"}}
```

Before instantiating a contract, let's verify that the code stored on the blockchain matches the `hello_world.wasm` binary we uploaded. We'll use the `diff` command to compare the contents of two files:

- `artifacts/hello_world.wasm` (our original binary)
- `download.wasm` (the binary retrieved from the blockchain)

The `diff` command will display any differences between the two files, ensuring that the uploaded code is correct.

```bash
mantrachaind query wasm code $CODE_ID $NODE download.wasm
diff artifacts/hello_world.wasm download.wasm
```

## Instantiating the Contract

To instantiate our *Hello World* Smart Contract, we'll use the following command, passing arguments as a JSON object, along with our `CODE_ID`, `wallet`, `label`, and transaction flag `TXFLAG` :

```bash
mantrachaind tx wasm instantiate $CODE_ID '{"message":"Hello, World!"}' --from wallet --label "hello_world" $TXFLAG -y --no-admin
```

Note : Do replace `wallet` with `wallet2` in case you’ve funded `wallet2`.

Once the process completes, We can fetch the contract details using `mantrachaind` and store it inside `CONTRACT` for interaction.

```bash
CONTRACT=$(mantrachaind query wasm list-contract-by-code $CODE_ID $NODE --output json | jq -r '.contracts[-1]')
echo $CONTRACT
```

![16.5.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm/16.5.webp?raw=true)

We can see the contract details like label, creator , block and code id by running the following command:

```bash
mantrachaind query wasm contract $CONTRACT $NODE
```

Upon instantiation, The `*hello_world*` contract will store the instantiation message data in the contract's storage, In order to view it we will query the entire contract state and use your corresponding value ( base64-encoded JSON object ) to decode the  base64-encoded string using the `base64 -d` command.

```bash
mantrachaind query wasm contract-state all $CONTRACT $NODE
```

Copy down the value string and replace in it the following before running it.

```bash
echo "<value-string>" | base64 -d
```

![16.6.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm/16.6.webp?raw=true)

And there you have it! You can now see the initial message "Hello, World!" stored within your Hello World Smart Contract on the MANTRA Testnet. This marks a significant milestone - your contract is now live and storing data on the blockchain!

## **That's a Wrap!**

Congratulations, you've successfully uploaded, optimized, and instantiated your first smart contract on the MANTRA testnet! You've also verified that the initial message has been stored correctly.

In the next lesson, we'll start building a real-world application - a Todo App! We'll explore the logic and how to interact with our smart contract. Get ready to take your blockchain development skills to the next level!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/1.%20Hello%20World%20in%20CosmWasm.md

Hello World in CosmWasm

# Introduction to To-Do List dApp

Hey Guys, in this lesson, we'll dive into the features and functionalities of our To-Do List dApp and discuss how we will be proceeding from now onwards on how to bring our dApp to life!

## The To-Do List dApp

Our To-Do List dApp is similar to Google Keep or Trello, but with a key difference - it's a decentralized application that empowers users to create, manage, and mark tasks as completed, all while maintaining full control over their data. Built on the secure and transparent Mantra Chain, our dApp offers a simple yet powerful tool for organizing your daily tasks, with the added benefits of blockchain technology.

## Features of our To-Do List dApp

- **Create Tasks:** Add new tasks with descriptions and priorities
- **Task Management:** Edit, delete, and mark tasks as completed
- **Decentralized Storage:** Tasks are stored securely on the Mantra Chain
- **User Authentication:** Only the owner can create, update, and delete their own tasks

![25.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/2.%20Introduction%20to%20To-Do%20List%20dApp/25.webp?raw=true)

## Functionality Overview

As previously discussed, our contract will also be having three entry points, enabling our To-Do List dApp to perform the following key functions:

- **Instantiate:** Initializes the contract by designating an owner
- **Execute:** Facilitates task management through three sub-functions:
    - **NewEntry:** Adds a new task with a description and priority
    - **UpdateEntry:** Modifies an existing task's description, status, and priority
    - **DeleteEntry:** Removes a task by its unique ID
- **Query:** Enables task retrieval through two sub-functions:
    - **QueryEntry:** Fetches a specific task by its ID
    - **QueryList:** Retrieves a paginated list of tasks

## Course Structure

In this course, we'll be building our To-Do List dApp from scratch. We'll cover the following topics:

- **CosmWasm Basics for the Contract** -
- **Adding To-Do Items** - Implementing the `NewEntry` functionality
- **Working with Vectors in CosmWasm** - Understanding how to work with vectors in Rust and CosmWasm
- **Implementing functions, Contract Management & Event Handling** - Updating and deleting tasks, contract management, and event handling

## The Checklist

To help you stay on track and ensure a smooth implementation process, we've put together a comprehensive checklist for our To-Do List dApp. Follow along and mark off each task as we progress through the lessons, and by the end, you'll have a fully functional decentralized application up and running!

✅ Setup the Rust project for our To-do dApp

✅ Implement Contract with the logic for Todo-App

✅ Implement Event handling

✅ Handle errors and events in our contract

✅ Deploy our dApp on the Mantra Chain

✅ Test and debug our dApp

## That's a Wrap!

In this lesson, we've introduced our To-Do List dApp and explored its features and functionalities. We've also outlined our course structure and checklist. In the next lesson, we'll dive into the basics of CosmWasm development using Rust. Get ready to code!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/2.%20Introduction%20to%20To-Do%20List%20dApp.md

Introduction to To-Do List dApp

# CosmWasm Blueprint for the Contract

Welcome back, MANTRA coders! get ready to dive into the heart of our decentralized application! In this lesson, we'll unlock the secrets of building a robust and scalable smart contract using CosmWasm. We'll explore the essential components and files that make up our contract's foundation, and discover how they work together in harmony to bring our decentralized vision to life.

Don't worry if some of this feels a bit intimidating at first. Remember, Rome wasn't built in a day, and neither are complex dApps. We'll take it step-by-step, starting with the basics and gradually building up to more sophisticated concepts. By the end of this lesson, you'll have a solid understanding of the core elements of a CosmWasm contract and be ready to start coding your own decentralized masterpiece!

## Quick Checkout

First, let’s quickly swap out our boilerplate with the corresponding front end for these functionalities.  At the root directory of your project, Run the following command : 

```bash
git checkout boilerplate02
```

Your Project structure will look like this:

![18.1.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/3.%20CosmWasm%20Blueprint%20for%20the%20Contract/18.1.webp?raw=true)

## The Blueprint of Your dApp: Understanding the CosmWasm Contract Structure

Before we dive into the nitty-gritty of coding our to-do list dApp, let's take a moment to map out the blueprint. Just like a well-organized construction project, a CosmWasm smart contract has a specific structure that helps you keep your code clean, organized, and maintainable. This structure is typically spread across five essential files:

1. `contract.rs`: This is the heart and soul of your smart contract. It's where you define the core logic of your dApp, including the functions that handle messages and queries, and the actions that modify the contract's state. Think of it as the brains of the operation, orchestrating all the behind-the-scenes magic.
2. `error.rs`: Errors are bound to happen in the complex world of code. This file is your contract's error handling manual. It defines custom error types to categorize and handle different exceptions that might occur during execution, providing valuable feedback to users and developers.
3. `msg.rs`: Communication is key, even for smart contracts! This file acts as the contract's communication interface, defining the structure of messages that can be sent to the contract (like commands to add or delete a task) and the responses it sends back.
4. `lib.rs`: This is the main entry point of your contract. Think of it as the front door, welcoming users and directing them to the appropriate parts of your dApp. It typically handles imports, declares modules, and exposes the necessary functions for external interaction.
5. `state.rs`: This file is your contract's memory bank. It defines the data structures that represent the state of your dApp. In our to-do list example, this would include information about each task, such as its description, status, and priority.

This modular structure might seem a bit overwhelming at first, but trust us, it's your secret weapon for building robust, maintainable, and scalable dApps. As we start coding our to-do list contract, you'll see how each of these files plays a crucial role in bringing your vision to life. We have already created these files(empty for now) for you in the project’s `src` folder.

## What's in [state.rs](http://state.rs/)?

Before we write a single line of code, let's think about how our to-do list will work and what kind of information it needs to remember:

- **Individual Tasks:** Each task needs a description, a status (e.g., "To Do," "In Progress," "Done"), and perhaps a priority level.
- **Task Identification:** We need a way to uniquely identify each task.
- **Task List:** We need to store a collection of tasks.

How do we represent this in Rust code? The answer is structs and enums! 

- **`Entry` Struct:** This struct will be our blueprint for individual to-do items. It will contain fields for:
    - `id`: A unique identifier (a number) for each task.
    - `description`: The task's description (a string of text).
    - `status`: The task's current status (an enum).
    - `priority`: The task's priority level (another enum).
    - `owner`: The owner of the to-do item (a string address).
- **`Status` and `Priority` Enums:** These enums will define the possible values for the `status` and `priority` fields of the `Entry` struct.
- **`LIST`:** This will be a map (a data structure that associates keys with values) to store our to-do items. We'll use the task's `id` as the key and the `Entry` struct itself as the value.
- **`ENTRY_SEQ`:** This will be a variable to help us generate unique IDs for each new task.
- **Dependencies**: We've already added the necessary dependencies in our `Cargo.toml` file. These dependencies include:
    - `cosmwasm_std`: The CosmWasm standard library, which provides essential tools and types for smart contract development.
    - `cosmwasm_schema`: A library for generating JSON schemas from Rust types, used for serialization/deserialization with CosmWasm.
    - `cw_storage_plus`: A library for working with persistent storage in CosmWasm contracts.
    

### Code in state.rs

Now that we know what will be added in state.rs, let’s see the code.

1. In [`state.rs`](http://state.rs) file start by importing the required files.

```rust
use cosmwasm_schema::cw_serde;
use cw_storage_plus::{Item, Map};
```

- `use cosmwasm_schema::cw_serde;`: Import the `cw_serde` macro from the `cosmwasm_schema` crate(library/package). This macro is used to make our structs and enums compatible with CosmWasm's serialization and deserialization mechanism.
- `use cw_storage_plus::{Item, Map};`: Import the `Item` and `Map` types from the `cw_storage_plus` crate. These are essential for interacting with the contract's storage.

2. Now let’s create the `struct Entry`.

```rust

#[cw_serde]
pub struct Entry {
    pub id: u64,
    pub description: String,
    pub status: Status,
    pub priority: Priority,
    pub owner: String,
}
```

- `#[cw_serde]`: This attribute makes the `Entry`, `Status`, and `Priority` types serializable and deserializable.
- `pub struct Entry { ... }`: This defines our `Entry` struct with the fields we discussed earlier (`id`, `description`, `status`, `priority`, `owner`). The `pub` keyword makes these fields publicly accessible.

3. Creating `Status` and `Priority` enums.

```rust
#[cw_serde]
pub enum Status {
    ToDo,
    InProgress,
    Done,
    Cancelled,
}

#[cw_serde]
pub enum Priority {
    None,
    Low,
    Medium,
    High,
}
```

- `pub enum Status { ... }`: This defines the `Status` enum with four variants representing the possible states of a task (`ToDo`, `InProgress`, `Done`, `Cancelled`).
- `pub enum Priority { ... }`: This defines the `Priority` enum with four variants representing the possible priority levels (`None`, `Low`, `Medium`, `High`).

4. Finally, let’s create out `LIST` and `ENTRY_SEQ`.

```rust
pub const ENTRY_SEQ: Item<u64> = Item::new("entry_seq");
pub const LIST: Map<u64, Entry> = Map::new("list");
```

- `pub const ENTRY_SEQ: Item<u64> = Item::new("entry_seq");`: This creates a persistent storage item named "entry_seq" that will hold a `u64` value. We'll use this to keep track of the next available ID for a new task.
- `pub const LIST: Map<u64, Entry> = Map::new("list");`: This creates a persistent storage map named "list." The keys will be task IDs (`u64`), and the values will be `Entry` structs representing the tasks themselves.
- An `Item` in `cw_storage_plus` is a container for storing a single value of a specific type. It's like a dedicated shelf in your closet for storing one specific item, like a pair of shoes. You can use `Item` to store things like:
    - Configuration settings for your contract (e.g., the owner's address)
    - Counters or sequences (e.g., the next available ID for a task)
    - Any other single piece of data that your contract needs to remember
- A `Map` in `cw_storage_plus` is like a dictionary or a hash table. It allows you to store multiple values, each associated with a unique key.  Think of it like a set of labeled drawers, where each drawer contains a specific type of item. You can use `Map` to store things like:
    - Lists of items (e.g., a list of to-do tasks, each identified by its ID)
    - User data (e.g., mapping user addresses to their balances)
    - Any other data where you need to quickly look up values based on a key

![18.2.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/3.%20CosmWasm%20Blueprint%20for%20the%20Contract/18.2.webp?raw=true)

With the `state.rs` file as our foundation, we're ready to move on to the heart of our to-do list contract—defining the messages it will understand. This is where your dApp starts to take shape, laying out the communication channels for interaction with the outside world.

## Wrap Up

Alright! We've just laid the groundwork for our to-do list dApp by understanding the blueprint of a CosmWasm smart contract and diving into the `state.rs` file. We've defined our data structures, set up storage mechanisms, and essentially created the "brain" for our dApp to remember and manage tasks.

In the next lesson, we'll shift our focus to the contract's communication channels. We'll explore `msg.rs`, `lib.rs`, and `error.rs`, understanding how they define the messages our contract will receive, the core logic it will execute, and how it will handle any unexpected situations. Get ready to breathe life into your to-do list dApp as we continue building it together!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/4.%20Getting%20Started%20With%20To-do%20DApp%20Developm/3.%20CosmWasm%20Blueprint%20for%20the%20Contract.md

CosmWasm Blueprint for the Contract

# Breathing Life into Your dApp: The Heart and Soul of Your Contract

Get ready to roll up your sleeves and dive into the core of our CosmWasm to-do list dApp! You've mastered the building blocks of Rust and gotten a taste of CosmWasm. Now, we'll unravel the secrets of the files that bring your contract to life: `msg.rs`, `lib.rs`, and `error.rs`. These files are the heart and soul of your dApp, defining how it communicates, functions, and gracefully handles unexpected situations. Let's get started!

## The Messenger: `msg.rs` - Your Contract's Communication Hub

Let's kick off our lesson by decoding the `msg.rs` file.  Think of this file as the communication protocol for your smart contract, defining the language it speaks with the outside world. It's like a set of instructions that tells users and other smart contracts what kind of actions they can request and what information they can expect in return.

### Designing the Conversation: What Does Our dApp Need to Say?

Before we dive into the code, let's brainstorm the kinds of messages our to-do list dApp needs to handle:

- **Creating New Tasks:** Users should be able to add tasks to their list.
- **Updating Tasks:** They should be able to modify existing tasks (description, priority, status).
- **Deleting Tasks:** They should be able to remove tasks from their list.
- **Viewing Tasks:** Users and other contracts should be able to query the list of tasks or get details about a specific task.

These actions will be triggered by different types of messages sent to the contract. Now, let's see how `msg.rs` defines these messages in code!

### Inside `msg.rs`

1. Imports

```rust
use crate::state::{Entry, Priority, Status};
use cosmwasm_schema::{cw_serde, QueryResponses};
```

- `use crate::state::{Entry, Priority, Status};`: This line brings in the `Entry`, `Priority`, and `Status` types from the `state.rs` file. These types are used to define the structure of messages and queries.
- `use cosmwasm_schema::{cw_serde, QueryResponses};`: This imports the `cw_serde` macro for serialization (converting Rust data structures into a format that can be sent over the network) and the `QueryResponses` trait for handling responses to queries.

2. The Welcome Message: `InstantiateMsg` 

```rust
#[cw_serde] // Allows this struct to be serialized and deserialized
pub struct InstantiateMsg {
    pub owner: Option<String>,
}
```

- **Purpose:** This struct defines the message sent when a new instance of your to-do list contract is created on the blockchain (during instantiation).
- **Fields:**
    - `owner`: An optional `String` field to set the owner of the contract. If no owner is provided, the sender of the instantiation message becomes the owner. This is essential for controlling who can add, update, or delete tasks.

3. Messages for Action: `ExecuteMsg`

```rust
#[cw_serde]
pub enum ExecuteMsg {
    NewEntry {
        description: String,
        priority: Option<Priority>,
        owner: String,
    },
    UpdateEntry {
        id: u64,
        description: Option<String>,
        status: Option<Status>,
        priority: Option<Priority>,
        owner: String,
    },
    DeleteEntry {
        id: u64,
        owner: String,
    },
}
```

- **Purpose:** This enum defines the different types of messages that your contract can handle to perform actions. Each variant represents a specific action.
- **Variants:**
    - `NewEntry`: This variant represents a message to create a new task. It includes the following fields:
        - `description`: The description of the task (required).
        - `priority`: The priority of the task (optional).
        - `owner`: The address of the owner of the task (required).
    - `UpdateEntry`: This variant represents a message to update an existing task. It includes the following fields:
        - `id`: The unique identifier of the task to update (required).
        - `description`: The updated description (optional).
        - `status`: The updated status (optional).
        - `priority`: The updated priority (optional).
        - `owner`: The address of the owner of the task (required).
    - `DeleteEntry`: This variant represents a message to delete a task. It includes the following fields:
        - `id`: The unique identifier of the task to delete (required).
        - `owner`: The address of the owner of the task (required).

4. Asking for Information: QueryMsg

```rust
#[cw_serde]
#[derive(QueryResponses)]
pub enum QueryMsg {
    #[returns(ListResponse)]
    QueryUserList { 
        user: String, 
        start_after: Option<u64>, 
        limit: Option<u32> 
    },
}
```

- **Purpose:** This enum acts as the question-and-answer guide for your contract. It specifies the kinds of information you can request and the format you'll receive the answers in.
- `QueryUserList { user: String, start_after: Option<u64>, limit: Option<u32> }`:
    - **Question:** "Show me the list of tasks owned by this specific `user`. Optionally, I can also tell you where to start and how many to show."
    - **Answer:** A `ListResponse` with tasks filtered by the specified user.
- The `start_after` and `limit` fields in `QueryList` and `QueryUserList` are your tools for pagination.  This means fetching results in smaller, more manageable chunks, especially when dealing with potentially large lists of tasks.
    - **`start_after` (Optional):** Tells the contract to start the list after the task with the specified ID. This is like saying, "I've already seen tasks 1 through 5, show me the next batch."
    - **`limit` (Optional):** Limits the number of tasks returned in the response. This helps prevent overwhelming your application with too much data at once.

5. Tailored Responses: EntryResponse and ListResponse

```rust
#[cw_serde]
pub struct ListResponse {
    pub entries: Vec<Entry>,
}
```

**Purpose:** These structs define the structure of the responses your contract sends back when it receives a query. Each response type is tailored to the corresponding query.

- **Field:**
    - `ListResponse`: This struct is the response to a `QueryList` message. It contains a vector (`Vec<Entry>`) of `Entry` items, representing the list of to-do items that match the query parameters.

![19.1.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions,%20Contract%20Managem/1.%20Breathing%20Life%20into%20Your%20dApp%20The%20Heart%20/19.1.webp?raw=true)

With `msg.rs`, we've defined the complete communication protocol for our to-do list dApp. Users and other contracts can now send messages to create, update, or delete tasks. They can also query the contract to retrieve information about tasks.

## [lib.rs](http://lib.rs/): The Gateway to Your Contract

Alright, developers, we've just unlocked the communication protocol of our to-do list dApp with `msg.rs`. Now, let's turn our attention to the `lib.rs` file, which acts as the main entry point and organization hub for our smart contract. Think of it as the front door to your dApp, welcoming users and directing them to the right places.

**The Role of lib.rs**

`lib.rs` plays a crucial role in structuring your CosmWasm project. It typically contains the following elements:

1. **Module Declarations:** These lines specify the different modules that make up your contract. Each module encapsulates a specific aspect of the contract's logic, such as handling messages, managing state, or defining error types.

```rust
pub mod contract; // Public module for handling contract execution logic
mod error;        // Private module for defining custom error types
pub mod msg;       // Public module for message and query definitions
pub mod state;      // Public module for state management
```

2. **Re-exports:** The `pub use` statement makes it easier to use items from other modules without having to write their full paths.

```rust
// Re-export ContractError for convenient use
pub use crate::error::ContractError;  
```

This line allows us to use `ContractError` directly in other modules (like `contract.rs`) without having to write `crate::error::ContractError` every time.

![19.2.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions,%20Contract%20Managem/1.%20Breathing%20Life%20into%20Your%20dApp%20The%20Heart%20/19.2.webp?raw=true)

This modular structure might seem like overkill for a simple to-do list dApp, but it's a best practice for larger, more complex projects.

In the next section, we'll delve into the `error.rs` file and discover how to handle errors gracefully in your CosmWasm smart contracts.

## Error Handling in CosmWasm: Preventing Your dApp from Crashing and Burning

Imagine you're building a self-driving car. It's cruising along smoothly, but suddenly, a pedestrian steps out onto the road. What happens next? Does the car slam on the brakes, swerve to avoid the person, or simply freeze up in confusion?  That's where error handling comes in!

In the world of smart contracts, errors can arise just as unexpectedly. A user might try to withdraw more tokens than they have, a critical piece of data might be missing, or an external system might fail to respond. Without proper error handling, your contract could crash, leading to lost funds or a disrupted user experience.

Just as a self-driving car needs a robust system to detect and respond to unexpected events, your CosmWasm contract needs a way to handle errors gracefully. This is where the `error.rs` file steps in, acting as your contract's safety net.

### error.rs: Your Contract's Error Dictionary

The `error.rs` file is like a dictionary of all the things that could go wrong in your contract. It defines custom error types that you can use to categorize different types of errors, making it easier to understand what went wrong when something goes awry.

Let's take a closer look at the `error.rs` file for our to-do list dApp:

```rust
use cosmwasm_std::StdError;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum ContractError {
    #[error("{0}")]
    Std(#[from] StdError),

    #[error("Unauthorized")]
    Unauthorized {},

    #[error("Custom Error val: {val:?}")]
    CustomError { val: String },
    // Add any other custom errors you like here.
}

```

Let me explain the different elements of this file:

1. **Imports:** We bring in the necessary tools from two libraries: `cosmwasm_std` (for standard CosmWasm errors) and `thiserror` (for making it easier to define custom errors).
2. **ContractError Enum:** We define a special type of variable called an `enum` (short for enumeration) named `ContractError`. This enum lists all the different types of errors our contract could encounter. Think of it like a menu of error options for your contract.
3. **Error Variants:**
    - `Std(#[from] StdError)`: This variant wraps any standard CosmWasm errors that might occur. It allows us to easily include pre-defined errors from the CosmWasm standard library, such as invalid messages or insufficient funds.
    - `Unauthorized {}`: This is a custom error we created specifically for our to-do list contract. It indicates that an action was attempted by someone who wasn't authorized (e.g., not the owner of the list).
    - `CustomError { val: String }`: This is a general-purpose error that lets us include a custom message with the error. For example, we might use it for a "Task not found" error.
    
    ![19.3.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions,%20Contract%20Managem/1.%20Breathing%20Life%20into%20Your%20dApp%20The%20Heart%20/19.3.webp?raw=true)
    

By defining these error types, we're essentially giving our contract a vocabulary to communicate what went wrong. When an error occurs, the contract can raise the appropriate error, providing valuable information to both the user and the developer.

## Wrap Up

Congratulations! You've just unlocked the inner workings of CosmWasm smart contracts. We've decoded the communication protocol (`msg.rs`), explored the contract's entry points (`lib.rs`), and learned how to gracefully handle errors (`error.rs`).  Think of these files as the foundation of your to-do list dApp, providing the structure and logic for its interactions with the world.

But the real excitement is just beginning! In the upcoming lessons, we'll dive headfirst into the `contract.rs` file, where we'll bring your to-do list dApp to life with Rust code. Get ready to transform your understanding of CosmWasm into a fully functional decentralized application.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/5.%20Implementing%20Functions%2C%20Contract%20Managem/1.%20Breathing%20Life%20into%20Your%20dApp%20The%20Heart.md

Breathing Life into Your dApp: The Heart and Soul of Your Contract

# The Core of Your Contract: -  Where the Magic Happens
Welcome back, devs!  We've laid the groundwork by defining our messages in `msg.rs`, setting up storage in `state.rs`, and establishing error handling in `error.rs`. Now, it's time to dive into the heart of our to-do list dApp: the `contract.rs` file.

This file is where all the action takes place. It's the brain of our smart contract, containing the logic that defines how our dApp will behave on the MANTRA Chain. 

## **Thinking Process: Designing the Contract's Logic**

Before we start coding, let's take a moment to brainstorm the core functionality our to-do list contract needs to provide:

1. **Initialization:** When the contract is first deployed, we need to set up some initial state, like keeping track of the next available task ID.
2. **Creating Tasks:** Users should be able to add new tasks to their list.
3. **Updating Tasks:** They should be able to modify existing tasks (e.g., change the description, mark as complete).
4. **Deleting Tasks:** They should be able to remove tasks they no longer need.
5. **Querying Tasks:** Users should be able to view their list of tasks or get details about a specific task.

To achieve this functionality, we'll need to define three special functions called *entry points*: `instantiate`, `execute`, and `query`.

## Entry Points: The Gates to Your Contract

Think of entry points as the gateways through which external entities (users or other contracts) can interact with your smart contract. Each entry point serves a distinct purpose:

- **`instantiate`:** This function is called when the contract is first created (deployed) on the blockchain. It's responsible for setting up the initial state of the contract.
- **`execute`:** This function is called whenever someone wants to make a change to the contract's state. It handles messages that trigger actions like adding, updating, or deleting tasks.
- **`query`:** This function is called when someone wants to read information from the contract without making any changes. It handles queries that retrieve data, such as getting the list of tasks.

## Understanding Imports: Gathering Your Tools

Think of the top of your `contract.rs` file as your toolbox, where you gather all the necessary tools and materials before starting your project. In Rust, these tools come in the form of external modules and crates (libraries) that provide pre-built functionality.

**What You'll Need to Import:**

In order to build our to-do list contract, we'll need to import the following items:

- **Core CosmWasm Functionality:**
    - `cosmwasm_std`: This crate provides the essential building blocks for CosmWasm smart contracts, including types for interacting with the blockchain, managing storage, and handling messages and queries.
    - `cw2`: This crate offers additional utilities and conventions for CosmWasm development, such as the `set_contract_version` function.
    - `cw_storage_plus`: This crate enhances the storage capabilities of CosmWasm, providing convenient ways to store and retrieve data.
- **Custom Modules:**
    - `crate::error::ContractError`: This imports the custom error types you defined in `error.rs` to handle specific errors that might arise in your contract's logic.
    - `crate::msg::{...}`: This imports the message and query types you defined in `msg.rs`, establishing the communication interface for your contract.
    - `crate::state::{...}`: This imports the state variables and data structures you defined in `state.rs`, which will hold the information about your to-do items.

Add the following lines in the [`contract.rs`](http://contract.rs) file:

```rust
#[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{
    to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Order, Response, StdResult,
};
use cw2::set_contract_version;
use cw_storage_plus::Bound;
use std::ops::Add;

use crate::error::ContractError;
use crate::msg::{ExecuteMsg, InstantiateMsg, ListResponse, QueryMsg};
use crate::state::{Entry, Priority, Status, ENTRY_SEQ, LIST};
```

![20.1.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/2.%20The%20Core%20of%20Your%20Contract%20-%20Where%20the%20Ma/20.1.webp?raw=true)

Let's break down this code snippet line by line to unravel its meaning and purpose in the CosmWasm to-do list contract:

1. `#[cfg(not(feature = "library"))]`:
    - This is a conditional compilation attribute. It tells the Rust compiler to include the following item (in this case, the `use cosmwasm_std::entry_point;` statement) only when the code is not being built as a library.
    - When building a smart contract, you typically don't want to include the `entry_point` macro if you're just compiling the contract as a library for testing or development purposes. This attribute helps streamline the compilation process and avoid unnecessary errors.
2. `use cosmwasm_std::entry_point;`:
    - This line imports the `entry_point` macro from the `cosmwasm_std` crate (library).
    - The `entry_point` macro is used to mark specific functions in your contract as entry points. These entry points are the functions that will be called by the CosmWasm runtime when interacting with your contract (e.g., instantiating, executing, or querying).
3. `use cosmwasm_std::{to_json_binary, Binary, Deps, DepsMut, Env, MessageInfo, Order, Response, StdResult};`:
    - This line imports several essential types and functions from the `cosmwasm_std` crate:
        - `to_json_binary`: Used to serialize Rust values into JSON-encoded binary format that can be efficiently stored and transmitted on the blockchain.
        - `Binary`: Represents a binary blob of data (array of bytes) that can be used to store or transmit information on the blockchain.
        - `Deps`: Provides read-only access to the contract's dependencies (storage, API, querier).
        - `DepsMut`: Provides mutable access to the contract's dependencies, allowing you to modify the storage.
        - `Env`: Provides information about the environment in which the contract is executing, such as block height and time.
        - `MessageInfo`: Contains information about the sender of a message and the funds they sent with it.
        - `Order`: An enum used for specifying the order in which to iterate over items in storage.
        - `Response`: Represents the response that the contract sends back after executing a message or query.
        - `StdResult`: A type used for representing the result of an operation that can either succeed (returning an `Ok` value) or fail (returning an `Err` with an error).
4. `use cw2::set_contract_version;`:
    - Imports the `set_contract_version` function from the `cw2` crate. This function is used to store the contract's version in storage for future reference, which is helpful for upgrades.
5. `use cw_storage_plus::Bound;`:
    - Imports the `Bound` type from the `cw_storage_plus` crate. It's used for specifying a range of keys when querying data from the contract's storage.
6. `use std::ops::Add;`:
    - Imports the `Add` trait from the Rust standard library. This trait defines the behavior for the `+` (addition) operator. It's used in the contract to increment the task ID counter.
7. `use crate::error::ContractError;`:
    - Imports the `ContractError` enum defined in your `error.rs` file. This enum is used for representing the different errors that your contract can encounter.
8. `use crate::msg::{EntryResponse, ExecuteMsg, InstantiateMsg, ListResponse, QueryMsg};`:
    - Imports the message and query types (`ExecuteMsg`, `InstantiateMsg`, `QueryMsg`) and response types (`EntryResponse`, `ListResponse`) from your `msg.rs` file.
9. `use crate::state::{Entry, Priority, Status, ENTRY_SEQ, LIST};`:
    - Imports the data structures (`Entry`, `Status`, `Priority`) and storage items (`ENTRY_SEQ`, `LIST`) from your `state.rs` file.

By understanding these imports, you now have a clearer picture of the tools and components available for building your to-do list contract.

## The `instantiate` Function: Preparing Your dApp for Launch

The `instantiate` function is the first thing that gets called when your smart contract is deployed to the MANTRA Chain. It's like setting up a new house – you need to furnish it, stock the fridge, and make it ready for guests to arrive. Similarly, the `instantiate` function prepares your contract to start interacting with the world by:

- **Version Control:** It stores the name and version of your contract in the blockchain's storage, ensuring a smooth upgrade path in the future.
- **Data Initialization:** It sets up any necessary data structures in the contract's storage. In our to-do list, this involves initializing a counter to track the unique IDs assigned to each task.
- **Confirmation:** It returns a message to the user (or another contract) confirming that the instantiation was successful.

**Let’s see what we will write in the code:**

1. **Define the function:** Create a function named `instantiate`.
    - It will need to be public (`pub`) so it can be called from outside.
    - Mark it with the `#[cfg_attr(not(feature = "library"), entry_point)]` attribute to tell CosmWasm this is a special function.
    - The function should accept four parameters (`deps`, `_env`, `_info`, `_msg`), which provide information about the environment and the message that triggered the function. We'll discuss these in more detail later.
    - It should return a `Result<Response, ContractError>`, meaning it will either return a successful response or an error.
2. **Set the contract version:** Use the `set_contract_version` function to record the contract's name and version in the blockchain's storage.
3. **Initialize the ID counter:** Start a counter at 0 to keep track of the IDs we'll assign to tasks.
4. **Return a response:** Indicate that the contract was successfully instantiated.

Now, let's see the code for the `instantiate` function:

```rust
// version info for migration
const CONTRACT_NAME: &str = "to-do-list";
const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");

#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    _msg: InstantiateMsg,
) -> Result<Response, ContractError> {
    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;

    ENTRY_SEQ.save(deps.storage, &0u64)?;

    Ok(Response::new()
        .add_attribute("method", "instantiate"))
}

```

![20.2.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/2.%20The%20Core%20of%20Your%20Contract%20-%20Where%20the%20Ma/20.2.webp?raw=true)

**Explanation:**

1. **`CONTRACT_NAME`, `CONTRACT_VERSION`**: These store details about the contract which are used while upgrading the contract in the future.
2. **`#[cfg_attr(not(feature = "library"), entry_point)]`:** This attribute specifies that the following function is an entry point for the contract. In simple terms, it tells the CosmWasm runtime that this function should be called when the contract is instantiated.
3. **`instantiate` Function Parameters:**
    - **`deps`:** Short for "dependencies," this gives you access to various tools and information about the blockchain environment, including the ability to read and write data to the contract's storage.
    - **`_env`:** Provides information about the environment in which the contract is being executed, such as the block height and timestamp. In this case, we are not using it, so we will just leave it here.
    - **`_info`:** Contains information about the sender of the message that triggered the contract execution. In this case, we are not using it, so we will just leave it here.
    - **`_msg`:** Contains the message sent by the user or another contract when instantiating the contract (as defined in `InstantiateMsg`). We are not using it now, so we will just leave it here.
4. **Return Type:** The function returns a `Result<Response, ContractError>`, indicating that it can either succeed (returning a `Response`) or fail (returning a `ContractError`).
5. **Function Body:**
    - `set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;`: This line uses the `set_contract_version` function (imported from the `cw2` library) to store the contract's name and version in the blockchain's storage.
    - `ENTRY_SEQ.save(deps.storage, &0u64)?;`: This line initializes the `ENTRY_SEQ` variable (from `state.rs`) to zero in the contract's storage. This variable will keep track of the next available ID for a new task.
    - `Ok(Response::new().add_attribute("method", "instantiate"))`: This line creates a `Response` object indicating successful instantiation and adds an attribute "method" with the value "instantiate" for informational purposes.

With the `instantiate` function in place, our contract is now ready to handle actions and queries, which we'll explore in the next lessons.

## Wrap Up

Awesome! We've successfully kicked off our deep dive into the core of our CosmWasm to-do list dApp.  In this lesson, we've explored the `contract.rs` file, understanding its role as the central logic hub for our contract. We've also dissected the `instantiate` function, which sets the stage for our dApp by initializing its state and preparing it to handle user interactions.

But the adventure is far from over! In the next lesson, we'll get into the nitty-gritty of interacting with our contract. We'll learn how to create new tasks and retrieve existing tasks. Get ready to make your to-do list dApp truly dynamic and functional!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/5.%20Implementing%20Functions%2C%20Contract%20Managem/2.%20The%20Core%20of%20Your%20Contract%20-%20Where%20the%20Magic%20Happens.md

The Core of Your Contract: - Where the Magic Happens

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/5.%20Implementing%20Functions%2C%20Contract%20Managem/3.%20Bringing%20Your%20To-Do%20List%20to%20Life%20Creatining%20and%20Querying%20Tasks.md

Bringing Your To-Do List to Life: Creating and Querying Tasks

# Updating and Deleting To-Do Items

Now that we've got the "add To-do" functionality down, it's time to tackle updating and deleting to-dos for users. Once we've wrapped those up, our Todo-App will be good to go!

## **Swap Boilerplate for To-Do Frontend**

Let's quickly replace our boilerplate with the corresponding frontend code for adding to-dos. Run the following command in your project's root directory:

```bash
git checkout boilerplate04
```

**No need to worry** - this update only touches the frontend components, so all your existing code is safe!

## Updating a Todo

To add functionality for updating a task, we'll create a function `execute_update_entry` that takes in the task's `id`, `description`, `status`, `priority`, and `owner`. This function will return a success response with the updated task’s ID.

```rust
pub fn execute_update_entry(
    deps: DepsMut,
    _info: MessageInfo,
    id: u64,
    description: Option<String>,
    status: Option<Status>,
    priority: Option<Priority>,
    owner: String,
) -> Result<Response, ContractError> {

    // Code goes here

}
```

Before updating the task, we'll fetch the existing task from storage and check if the owner matches the one trying to update it. If the ownership does not match, return an `Unauthorized` error.

```rust
pub fn execute_update_entry(
    deps: DepsMut,
    _info: MessageInfo,
    id: u64,
    description: Option<String>,
    status: Option<Status>,
    priority: Option<Priority>,
    owner: String,
) -> Result<Response, ContractError> {

    // Load the existing task from storage
    let entry = LIST.load(deps.storage, id)?;

    // Check if the owner matches the one trying to update
    if owner != entry.owner {
        return Err(ContractError::Unauthorized {});
    }
}
```

To update a specific task, we first need to create a new task with the updated fields. Next, we save this updated task to storage. Finally, we return a success response that includes the ID of the updated task.

```rust
pub fn execute_update_entry(
    deps: DepsMut,
    _info: MessageInfo,
    id: u64,
    description: Option<String>,
    status: Option<Status>,
    priority: Option<Priority>,
    owner: String,
) -> Result<Response, ContractError> {
    let entry = LIST.load(deps.storage, id)?;
    if owner != entry.owner {
        return Err(ContractError::Unauthorized {});
    }

    // Create a new task with the updated fields
    let updated_entry = Entry {
        id,
        description: description.unwrap_or(entry.description),
        status: status.unwrap_or(entry.status),
        priority: priority.unwrap_or(entry.priority),
        owner,
    };

    // Save the updated task to storage
    LIST.save(deps.storage, id, &updated_entry)?;

    // Return a success response with the updated task's ID
    Ok(Response::new()
        .add_attribute("method", "execute_update_entry")
        .add_attribute("updated_entry_id", id.to_string()))
}

```

The `unwrap_or` method checks if an `Option` contains a value. If it does, it uses that value; if not, it falls back to the provided default, which in this case are existing values from the `entry` struct. And there you go, our `execute_update_entry` function is ready.

## Deleting a To-Do

To implement functionality for deleting a task, we will create a function `execute_delete_entry` that takes in the task's `id` and `owner`. This function will return a success response with the deleted task’s ID. 

```rust
pub fn execute_delete_entry(
    deps: DepsMut,
    _info: MessageInfo,
    id: u64,
    owner: String,
) -> Result<Response, ContractError> {

    // Code goes here
    
}
```

Let’s fetch the task from storage using its `id`, and then verify that the `owner` provided matches the owner of the task stored in the database. If the ownership does not match, return an `Unauthorized` error.

```rust
pub fn execute_delete_entry(
    deps: DepsMut,
    _info: MessageInfo,
    id: u64,
    owner: String,
) -> Result<Response, ContractError> {

    // Load the existing task from storage
    let entry = LIST.load(deps.storage, id)?;

    // Check if the owner matches the one trying to delete
    if owner != entry.owner {
        return Err(ContractError::Unauthorized {});
    }
}
```

If the ownership check passes, remove the task from storage and return a success response with the ID of the deleted task.

```rust
pub fn execute_delete_entry(
    deps: DepsMut,
    _info: MessageInfo,
    id: u64,
    owner: String,
) -> Result<Response, ContractError> {
    let entry = LIST.load(deps.storage, id)?;
    if owner != entry.owner {
        return Err(ContractError::Unauthorized {});
    }

    // Remove the task from storage
    LIST.remove(deps.storage, id);

    // Return a success response with the deleted task's ID
    Ok(Response::new()
        .add_attribute("method", "execute_delete_entry")
        .add_attribute("deleted_entry_id", id.to_string()))
}
```

Our `execute_delete_entry` function is now complete and ready for handling task deletions. Your `contract.rs` should now look like [this](https://github.com/0xmetaschool/building-on-MANTRA-chain/blob/complete-code/contract/src/contract.rs). 

This completes our smart contract for the to-do app. Next, let’s deploy it and test its functionality with our frontend boilerplate.

## Compiling our Smart Contract


⚠️ **Important**: After switching branches, the `mantrachaind-cli.env` file may have reset to default values. Before proceeding, ensure:

1. Your terminal is in the `building-on-MANTRA-chain/contract` directory
2. The contents of `mantrachaind-cli.env` match your OS-specific configuration from Lesson 5
   - For Linux users: Verify Linux-specific settings
   - For MacOS users: Ensure MacOS-specific values are set

Once verified, source the environment file:
```bash
source mantrachaind-cli.env
```

> 💡 **Tip**: If the values don't match your OS configuration, copy your working environment variables from Lesson 5 before proceeding.


Next, compile our smart contract by running the following command:

```bash
cargo build --target wasm32-unknown-unknown --release
```

![22.1.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items/22.1.webp?raw=true)

Now before we upload the `to_do_list.wasm` to the Testnet , we will need to optimize it.

## Optimizing our Contract

⚠️ Just make sure you've got Docker up and running on your machine before you get started.

### For Linux, Windows WSL, and Intel-based Mac:

```bash
cargo run-script optimize
```

### For Mac with M1/M2 chip:

```bash
cargo run-script optimize-64
```

These scripts will execute the optimization process using the appropriate Docker image for your system architecture. The optimized `.wasm` file will be generated in the `artifacts` directory.

![22.2.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items/22.2.webp?raw=true)

## Deploying the Contract

Run the following command to upload your wasm binary to the network and store the response in the `RES` variable. This response will contain the unique Code ID of your uploaded binary.

Note : If you have funded the wallet named under ‘wallet2’ then do specify “wallet2” instead of “wallet” in the following commands. 

```bash
RES=$(mantrachaind tx wasm store artifacts/to_do_list.wasm --from wallet $TXFLAG -y --output json)
echo "Store response: $RES"
```

Next, use the `RES` variable to request the transaction hash, stored as `TX_HASH`. With this hash, you can then fetch the full transaction details, including events, and extract the `CODE_ID` from the response.

```bash
TX_HASH=$(echo $RES | jq -r .txhash)
CODE_ID=$(mantrachaind query tx $TX_HASH $NODE -o json | jq -r '.events[] | select(.type == "store_code") | .attributes[] | select(.key == "code_id") | .value')
echo "Code ID: $CODE_ID"
```

![22.3.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items/22.3.webp?raw=true)

# Instantiating the Contract

To instantiate our smart contract, we'll follow these steps to ensure proper setup and verification. Make sure you have the `CODE_ID` from the previous deployment step. Incase you’ve funded wallet2 then do replace `wallet` with `wallet2`  in the following set of commands. 

### 1. Get Wallet Address

First, let's fetch your wallet address:

```bash
WALLET_ADDR=$(mantrachaind keys show wallet2 -a)
echo "Wallet address: $WALLET_ADDR"
```

### 2. Instantiate the Contract

Now we'll instantiate the contract using your wallet address as the owner:

```bash
INIT_TX=$(mantrachaind tx wasm instantiate $CODE_ID '{"owner":"'$WALLET_ADDR'"}' \
--from wallet2 \
--label "to-do-list" \
--no-admin \
$TXFLAG \
--output json -y)
echo "Instantiate response: $INIT_TX"
```

### 3. Get Transaction Hash

Fetch the transaction hash for verification:

```bash
INIT_TX_HASH=$(echo $INIT_TX | jq -r .txhash)
echo "Instantiate tx hash: $INIT_TX_HASH"
```

### 4. Get Contract Address

Finally, retrieve and verify the contract address:

```bash
CONTRACT_ADDR=$(mantrachaind query tx $INIT_TX_HASH $NODE --output json | jq -r '.events[] | select(.type == "instantiate").attributes[] | select(.key == "_contract_address").value')
echo "Contract address: $CONTRACT_ADDR"
```

![22.4.webp](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items/22.4.webp?raw=true)

### Important Note

Once you have the contract address, copy it and paste it into the `.env` file located in the `building-on-MANTRA-chain/interface/` directory. This address will be needed for future interactions with your smart contract.

## Interacting with the Frontend

To start our frontend, navigate to the `interface` directory, install all dependencies using `npm install —-legacy-peer-deps`, and then run the development environment using `npm run dev`.

```jsx
cd interface
npm install --legacy-peer-deps
npm run dev
```

![31.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items/31.webp?raw=true)

Once the development server is up and running, you can access your application in your web browser by navigating to the localhost URL. 

### **Testing the Todo App**

- Click on “Connect Wallet” button to get started
- Add a Todo and use the the dropdown menu to select it’s priority. Click on the Add button and approve the transaction.
- You can now test out updating and deleting the todo using the clickable icons on the right.

![33.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items/33.webp?raw=true)

## Quick Check Point

Update your code to the forked GitHub Repository using the following commands: 

```bash
git add .
git commit -m "todo-complete"
git push
```

## That’s a Wrap

Congratulations! You've successfully supercharged your to-do list dApp with update and delete functionalities, giving users full control over their tasks on the MANTRA Chain. Not only that, but you've also learned how to interact with your contract from a frontend, making your dApp accessible and user-friendly.

With the completion of these essential features, you've officially built your first fully functional decentralized application on MANTRA Chain! Take a moment to celebrate this milestone, and get ready to dive deeper into the exciting world of CosmWasm development as we explore more advanced topics and build even more complex dApps in future lessons.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/refs/heads/main/Building%20on%20MANTRA%20Chain/5.%20Implementing%20Functions%2C%20Contract%20Managem/4.%20Updating%20and%20Deleting%20To-Do%20Items.md

Updating and Deleting To-Do Items

# Wrap Up

You've officially conquered your first MANTRA Chain dApp Development!  Give yourselves a well-deserved round of applause for your dedication and perseverance.  In this whirlwind journey, we've explored a wide array of concepts and skills, from the foundations of blockchain technology to the intricacies of smart contract development.

So, what have you accomplished in this epic adventure?  Let's recap the highlights:

- **Cosmos Odyssey:** You navigated the vast and interconnected Cosmos ecosystem, understanding its architecture, core components, and the power of inter-blockchain communication.
- **WebAssembly Wizardry:** You delved into the inner workings of WebAssembly (Wasm), the secret sauce behind CosmWasm's flexibility and performance.
- **Cosmos SDK Expertise:** You mastered the Cosmos Software Development Kit, the versatile toolbox that empowers developers to build custom blockchains.
- **Rust Revelation:** You embraced the Rust programming language, learning its unique features that make it ideal for secure and efficient smart contract development.
- **Setting Up Your Launchpad:** You equipped your development environment with the essential tools for building and deploying CosmWasm contracts on the MANTRA Chain.
- **Rust Deep Dive:** You explored the fundamentals of Rust, from variables and data types to functions, structs, enums, options, vectors, and more. You've learned how to harness the power of these building blocks to create well-structured and expressive code.
- **CosmWasm Mastery:** You've conquered the core concepts of CosmWasm, understanding how to write smart contracts that can interact with the MANTRA Chain and leverage its unique features.
- **dApp Dynamo:** You've put your knowledge into action by building a fully functional to-do list dApp on MANTRA Chain, complete with frontend interaction.

You've come a long way, and you should be incredibly proud of your accomplishments!

![aptos-c4-l10.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/Building%20on%20Mantra%20-%20C2/6.%20Conclusion/1.%20Wrap%20Up/aptos-c4-l10.webp?raw=true)

## ⚒️ A small yet important request

Here is great news for you! This is a 100% open-source project like all the other projects on our platform. You can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects). If you find any issues in the course, please feel free to resolve them. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub, too.

While you're learning, don't forget to join the vibrant MANTRA Chain community!

- **Follow & Subscribe:** Stay in the loop on [X (formerly Twitter)](https://twitter.com/MANTRA_Chain), [LinkedIn](https://www.linkedin.com/company/mantrachain/), [YouTube](https://www.youtube.com/@MANTRAChain) and [Instagram](https://www.instagram.com/mantra_chain/).
- **Chat & Connect:** Join the conversation on [Discord](https://discord.com/invite/gfks4TwAJV) & [Telegram](https://t.me/MANTRA_Chain), and read about MANTRA Chain on [Medium](https://mantrachain.medium.com/).

By actively participating in the community, you'll gain valuable insights, network with like-minded individuals, and stay at the forefront of the decentralized finance revolution.

And of course, don't forget to show your support for Metaschool as well!

- **Star the Metaschool Repository:** Give us a star on [GitHub](https://github.com/0xmetaschool/Learning-Projects) to show your appreciation for our educational resources.
- **Follow Metaschool on Social Media:** Stay connected with us on [X (formerly Twitter)](https://twitter.com/0xmetaschool) and [LinkedIn](https://www.linkedin.com/company/0xmetaschool/) for the latest updates and course announcements.
- **Subscribe to the Metaschool [YouTube Channel](https://www.youtube.com/@0xmetaschool/):** Watch our educational videos and tutorials to expand your blockchain knowledge.

## **🎊 Congratulations**

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

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Building%20on%20MANTRA%20Chain/6.%20Conclusion/1.%20Wrap%20Up.md

Warden Protocol

30 days of solidity

Fuel Marathon

Aptos Marathon

Core Marathon

Sui Marathon

Mantra

Web3 Templates

AI Templates

AI Tools

Mantra