A hands-on course for devs to create their first BRC-20 token. Learn Clarity programming language and build on the Stacks Blockchain. Register now!

Yo, welcome to the tutorial “Code a BRC-20 token in Clarity on Stacks Blockchain” This guide will show you how to create and deploy your own BRC-20 token on the Stacks blockchain using Clarity as the primary programming language.

First up, you gotta kn

Code a BRC-20 token in Clarity on Stacks Blockchain

Learn prerequisites and learning outcomes and get started with the Stacks Blockchain.

# What Are We Building Today?


gm everyone, I am Fareeha and I am are very excited to bring the first ever learning tutorial for developers on Stacks blockchain on Metaschool.

So what are we building today? Today we’re gonna write a BRC20 token in Clarity programming language and deploy it on the Stacks blockchain. Brace yourself as I take you on a thrilling journey into the world of Stacks Blockchain.

Why Stacks blockchain? Do you know bitcoin has been running for more than 10 year with ZERO downtime? Well Stacks will help you build on bitcoin. They have more than 100+ partnership with okcoin, Coinbase, USDC, [Blockchain.com](http://Blockchain.com) to name a few.

Not only this Stacks has more than 5K+ active developers with more than 1B dollar in total locked value!

## Course overview

We will:

1. Develop understanding of Stack blockchain
2. Learn about Clarity and its basics
3. Write a contract in Clarity
4. Set up Hiro Wallet and online IDE
5. Deploy the Clarity smart contract on Stacks

## Who exactly should take this course?

You should have a basic knowledge of programming concepts like object-oriented programming, data structures, and algorithms. This will help you have a fast start to this tutorial. 

## Prerequisites

We will be using online tools for coding and deployment so you don't need to install anything.

## Proof of completion

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

![Untitled](https://github.com/0xmetaschool/Learning-Projects/assets/129931419/39ec7f2b-da59-4a3c-b81f-90e3fe8c50c4)

Now before we move forward, let’s set some house rules first.
1. Pleaseeeee do your quick assignments properly. 
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. Stay happy and positive!”



## 🛠 Contributing to this project!

Here’s the GREAT news for you! This is an open source project, you can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects). If you find an issues in the course, please feel free to resolve it.
We, at Metaschool, love love love contributions by our community and we give acknowledgement to contributors in our discord and GitHub profile too.

**Fun fact:** All our projects are 100% open-source.

Also, don’t forget to star ⭐️ our repository! we will be very thankful! ♥️

Alright guys, no need to wait any longer, let's dive right into our awesome Stacks Blockchain course!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Building%20Today%3F.md

What Are We Building Today?

# Into the World of Stacks

So hey folks, we just understood what is required to start this course. If you are here, it means you have a knack to learn something new. That new is yes, Stacks blockchain!!

# What the heck is Stacks blockchain

Stacks is an awesome blockchain technology that works hand-in-hand with Bitcoin to make smart contracts and decentralized apps a reality. It's like a layer of magic that brings together the power of Bitcoin and the creativity of developers. With Stacks, you can create amazing apps in a secure and reliable environment, where the strength of Bitcoin's security features merges seamlessly.  

The STX token is the native currency used on the Stacks blockchain to pay for gas fees required to execute transactions. The Clarity programming language is used to write smart contracts on the Stacks blockchain, providing a simple and secure way for developers to create and deploy decentralized applications.

<center>
<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/Into%20the%20World%20of%20Stacks%2001f0120e256e401992477925ece6c656/68747470733a2f2f692e696d6775722e636f6d2f7a7a776e436e592e706e67.png?raw=true" alt="Girl in a jacket" style="width:500px;height:140px;">
</center>


## How does Stacks even work

Imagine you and your neighbors have come together to create a community garden. To make the garden successful and sustainable, everyone needs to contribute and ensure its smooth operation.

**Staking**: Staking is similar to contributing resources and effort to the community garden. Here's how it relates:

a. **Acquiring stakes**: Just like you need to acquire STX tokens for staking, community members need to acquire stakes in the garden. These stakes represent their ownership and participation in the garden's success.

b. **Choosing a delegate**: In the community garden, there may be experienced gardeners who can take the responsibility of managing and overseeing the garden's operations. As a participant, you can choose a trusted delegate from the community who will lead the efforts and ensure the garden thrives.

c. **Delegating your stake**: Once you've chosen a delegate, you delegate a portion of your stakes to them. This means you entrust them with a certain amount of responsibility to make decisions and maintain the garden's well-being. By doing so, you contribute to the garden's success and security.

d. **Earning rewards**: As the garden grows and produces a bountiful harvest, the delegate recognizes the efforts of all participants. They distribute the rewards in the form of fresh produce, seeds, or even gardening tools. The more stakes you have delegated, the greater share of the rewards you receive.


<center>
<img src="https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/Into%20the%20World%20of%20Stacks%2001f0120e256e401992477925ece6c656/free-medal-38-124197.webp" alt="Girl in a jacket" style="width:240;height:240px;">
</center>


**Mining**: Mining on the Stacks blockchain, or stacking, can be compared to an activity in the community garden called "harvesting parties." Here's how it relates:

a. **Setting up a harvesting group**: In the community garden, members can form a group to participate in harvesting parties. This group consists of volunteers who work together to collect ripe fruits and vegetables from the garden.

b. **Contributing to the harvest**: As a member of the harvesting group, you actively participate in the process. You help gather produce, sort it, and prepare it for distribution or personal use.

<center>
<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/Into%20the%20World%20of%20Stacks%2001f0120e256e401992477925ece6c656/cryptocurrency-mining-service-color-icon-bitcoin-crypto-mining-cryptocurrency-business-bitcoin-coins-stack-with-pickaxe-isolated-illustration-vector.png?raw=true" alt="Girl in a jacket" style="width:240;height:240px;">
</center>

    
c. **Sharing the rewards**: Once the harvest is complete, the group shares the rewards based on their contribution. This could be dividing the harvested produce among the group members or allocating extra resources, such as seeds or gardening supplies, to those who participated actively.

d. **Reaping the benefits:** By joining the harvesting group and actively participating, you earn a share of the rewards. The more you contribute and participate in the harvesting parties, the more benefits you receive from the garden's yield.
    

In both staking and stacking, active participation and contribution are key to earning rewards and benefiting from the community garden or the Stacks blockchain. By aligning these concepts with a familiar scenario like a community garden, it becomes easier to understand the principles behind staking and mining.

## Wrap up

Overall, Stacks blockchain is an innovative platform that combines the security of Bitcoin with the flexibility of smart contracts. We explored mining and stacking with a real-world example to understand how Stacks work.

So, we covered the cool world of Stacks. Now we will also explore the awesome world of Clarity. 🌐 Stay tuned ‼️

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/2.%20Into%20the%20World%20of%20Stacks.md

Into the World of Stacks

# What is Clarity?

Welcome back! So we completed learning about Stacks blockchain. Awesome, you did great! Well, get ready because in this lesson, we will dive into Clarity language. ©️ Are you excited? Let's get started! 

# Introduction to Clarity Programming Language

Clarity is a powerful programming language developed by Blockstack for writing smart contracts on the blockchain. Smart contracts are self-executing contracts that can automate the process of exchanging value or assets, without the need for intermediaries.

<center>
<img src="https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/What%20is%20Clarity%2026ed9f755bba46199bf17728d8c1debb/clarity_meta.png" alt="Girl in a jacket" style="width:500px; height:250px;">
</center>



## Features of Clarity Programming Language

Here are some of the main features of Clarity:

### Safety and Security

Clarity provides safety and security through its statically typed design, which reduces the risks of bugs, errors, and vulnerabilities. Its built-in functions for handling blockchain transactions and managing assets, as well as its support for common data types, enable developers to create reliable and secure smart contracts.

<center>
<img src="https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/What%20is%20Clarity%2026ed9f755bba46199bf17728d8c1debb/icons8-safety-100.png" alt="Girl in a jacket" style="width:100px; height:100px;">
</center>

### High-Level Language

Clarity is a high-level language that is easy to learn, read, and write. This makes it accessible to both experienced developers and beginners who are new to blockchain programming. Clarity's syntax is similar to that of other programming languages, but it includes specific features that are tailored to smart contract development.

### Tailored for Smart Contract Development

Clarity includes built-in functions for handling blockchain transactions, managing assets, and implementing complex logic. It also supports several data types that are commonly used in programming languages, such as integers, booleans, and lists. Clarity's data types provide a way to represent and manipulate various types of data within a smart contract, enabling developers to implement complex logic and functionality.


<center>
<img src="https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/What%20is%20Clarity%2026ed9f755bba46199bf17728d8c1debb/icons8-contract-100.png" alt="Girl in a jacket" style="width:100; height:100;">
</center>

### Custom Tools and Libraries

Clarity is an open-source language, which means that developers can create custom tools and libraries to enhance its functionality. This makes it possible to extend Clarity's capabilities and create custom solutions for specific use cases.

### Compatible with Stacks Blockchain

Clarity was specifically designed to write contracts on the Stacks blockchain, which is a secure and decentralized blockchain network. This means that Clarity has been optimized for safety, security, and efficiency, enabling developers to create contracts that are reliable and secure.

## Wrap up

Overall, Clarity is a powerful programming language that provides a safe, accessible, and efficient way to write smart contracts on the blockchain. Its features are tailored to smart contract development, and it is compatible with the Stacks blockchain, making it a popular choice for developers who want to create secure and reliable contracts.

Whether you are a seasoned developer or a beginner, Clarity is a powerful language that can help you build secure and transparent smart contracts on the blockchain.

COOOL ‼️ We have buckled ourselves up with the introductory knowledge of Stacks and Clarity. Now, let’s learn the syntax of Clarity so we can code and build in it!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/3.%20What%20is%20Clarity.md

What is Clarity?

Let’s Get Started

Get started with Clarity programming language and write and deploy your first smart contract.

# Clarity Basics - I

Welcome back!  Remember what we talked about in the last lesson? We learned about Clarity and how it works. Well, get ready because in this lesson, we're going to dive into the fun part - basics of Clarity! Are you excited? Let's get started! 

Before starting, there’s something unique about clarity and that is we use brackets **()** to define our statements. So let’s continue our learning journey!

## Data Types

Clarity supports several data types that are commonly used in programming languages, including:

- `int`: Represents integer numbers, such as `42` or `123`.
- `uint`: Represents unsigned integers, such as `10` or `1000`.
- `bool`: Represents boolean values, which can be either `true` or `false`.
- `principal`: Represents a blockchain address, which is a unique identifier for an account or contract.
- `buff`: Represents a buffer, which is a sequence of bytes used for storing data.
- `list`: Represents a list, which is an ordered collection of items of the same data type.
- `tuple`: Represents a tuple, which is an ordered collection of items of different data types.

Clarity also supports type aliases, which allow developers to create custom names for existing data types. This can be useful for improving the readability and maintainability of code. An example of this could be:

```
;; We define a type alias Username that represents a string.
;; We can then use this alias throughout our code, 
;; making it easier to understand the purpose and intent of the data.
(type-alias Username string)

;; The validate-username function takes a Username parameter 
;; and validates whether it's a valid username or not. 

(define-public (validate-username (username Username))
  (if (is-valid-username? username)
    (ok)  ;; If the username is valid, it returns an "ok" result.   
    ;; Otherwise, it returns an "err" result with a message that shows invalidity.
		(err "Invalid username")))

;; this function is a helper function that contains the 
;; actual logic for validating a username. 
;; It takes a Username parameter and performs the necessary 
;; checks to determine its validity.
(define-public (is-valid-username? (username Username))
  ; Implementation of username validation logic goes here
  ; (e.g., checking length, character restrictions, etc.)
)
```

Overall, Clarity's data types provide a way to represent and manipulate various types of data within a smart contract, enabling developers to implement complex logic and functionality.

## Variables

In Clarity, there are two types of variables: Local and State.

1. **Local** variables are declared inside functions and are temporary, existing only within the function's scope. They are not stored on the blockchain.
2. **State** variables are declared outside functions and maintain the state of the smart contract. They are accessible from anywhere in the contract and are stored on the blockchain for long-term use.

### Syntax

We can declare a state variable as:

<center>
<img src="https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Clarity%20Basics%20-%20I%20b24d53871cc143f3af899cb36a4b20ae/clarity_(1).jpg" alt="Girl in a jacket" style="width:500px; height:200px;">
</center>



- `define-data-var` : keyword used to define the variable
- `var-name` : name of the variable
- `var-type` : type of the variable that is defined
- `initial-value` : value of the variable

You can **set** value of the variable by:

```
(var-set my-variable 5000)
```

You can **get** value of the variable by:

```
(var-get my-variable)
```

You can **print** value of the variable by:

```
(print (var-set my-variable 5000))
```

You can add **comment** by adding anything after `;;`. 

Another cool aspect of Clarity is that it also supports type inference, which means that the data type of a variable can be automatically determined based on its initial value. For example, if you assign the value `true` to a variable, Clarity will automatically infer that the variable is of type boolean.

## Wrap up

In this lesson, we learned about the basics of Clarity. We talked about data types, including integer, boolean, and blockchain address, and how they are used in Clarity. We also discussed the two types of variables in Clarity, local and state, and how they are declared and used. Additionally, we covered type inference and how it makes writing code easier. 

Next, we will cover more about Clarity basics so stay tuned for the next lesson!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/1.%20Clarity%20Basics%20-%20I.md

Clarity Basics - I

# Clarity Basics - II

Welcome back! We learned about Clarity basics. Well, get ready because in this lesson, we're going to dive deeper into the fun part - basic arithmetic operations and functions **[](https://www.stacks.sahilaujla.com/docs/intro-to-clarity#basic-arithmetic-operations)**! Are you excited? Let's get started!

## Basic Arithmetic Operations

Clarity provides basic arithmetic operations that can be used to perform mathematical calculations within a smart contract. These operations include addition, subtraction, multiplication, and division.

### Addition

To perform addition in Clarity, you can use the `+` operator. For example, to add two integer values `x` and `y`, you can write:

```
(+ x y)
```

### Subtraction

To perform subtraction in Clarity, you can use the `-` operator. For example, to subtract two integer values `x` and `y`, you can write:

```
(- x y)
```

### Multiplication

To perform multiplication in Clarity, you can use the `*` operator. For example, to multiply two integer values `x` and `y`, you can write:

```
(* x y)
```

### Division

To perform division in Clarity, you can use the `/` operator. For example, to divide two integer values `x` and `y`, you can write:

```
(/ x y)
```

### Modulo operation

Clarity also supports the modulo operation, which returns the remainder of dividing one integer value by another. To perform modulo in Clarity, you can use the `%` operator. For example, to calculate the remainder of dividing `x` by `y`, you can write:

```
(% x y)
```

Overall, basic arithmetic operations in Clarity provide a way to perform mathematical calculations within a smart contract, enabling developers to implement complex logic and functionality.

## Functions

Functions are a fundamental building block of Clarity programming language. They provide a way to encapsulate and reuse code, making it easier to create complex smart contracts.

To define a function in Clarity, you can use the `define-function` keyword followed by the function name, its arguments, and its return type. For example, to define a function named `add` that takes two integer arguments and returns their sum, you can write:

```
(define-function (add (x int) (y int)) int
  (+ x y))

```

### Types of function

Clarity provides three types of functions: public, private, and read-only.

- **Public functions** are functions that can be called by anyone who has access to the smart contract. These functions can modify the state of the contract and can be used to implement the core functionality of the contract. You can use the keyword `define-public` to define a public function.
- **Private functions** can only be called from within the smart contract and cannot be accessed by external parties. These functions are typically used to implement helper functions or other internal logic. You can use the keyword `define-private` to define a private function.
- **Read-only functions** are functions that do not modify the state of the smart contract and can be called by anyone, including parties who do not have access to the contract. These functions are typically used to retrieve information from the contract, such as current balances or other data. You can use the keyword `define-read-only` to define a read-only function.

We can define the above function as the following too:

```
(define-read-only (add (x int) (y int)) int
  (+ x y))
;; There is no need for a return statement in Clarity, 
;; just write the expression !!!
```

## Wrap up

We learned about basic arithmetic operations and functions in Clarity. Arithmetic operations include addition, subtraction, multiplication, division, and modulo operation. Clarity provides three types of functions: public, private, and read-only. Developers can write powerful and flexible smart contracts using these tools.

Next, we will write a calculator code in Clarity so stay tuned for the next lesson!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/2.%20Clarity%20Basics%20-%20II.md

Clarity Basics - II

# Writing a Calculator in Clarity

Welcome back! So we completed learning about Clarity basics. Awesome, you did great! Well, get ready because in this lesson, we're going to dive into writing our own calculator in Clarity! Are you excited? Let's get started!

## Writing the code in Clarity

To write a calculator in Clarity, we will do these steps:

- We will go for four arithmetic operations: addition, subtraction, multiplication, and division.
- We will create functions for each of the operations.

So, we did define the addition function in the last lesson, it was this:

```
(define-read-only (add (x int) (y int)) int
  (+ x y))
```

We will define for the other operations as well:

```
(define-read-only (subtract (x int) (y int))  
  (- x y))

(define-read-only (multiply (x int) (y int))  
  (* x y))

(define-read-only (divide (x int) (y int))  
  (/ x y))
```

## Testing it out

So folks, you must be wondering where can we run our code?

We have got you! You can go to the link of [Clarity Tools](https://clarity.tools/code/hello). Clear all the pre-written code and paste your calculator code there.


![Untitled](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Writing%20a%20Calculator%20in%20Clarity%200319d46f94fc43dc9f09100b397ff217/copy-paste.gif)

Now let’s test these functions by calling them in ClarityTools. The output will be displayed on the left side of the screen in green.

You can use the following test functions: 

```
(add 5 5)
(subtract 10 5)
(multiply 43 3)
(divide 32 2)
```

## Output

The output will be similar to this: 



![Untitled](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Writing%20a%20Calculator%20in%20Clarity%200319d46f94fc43dc9f09100b397ff217/Screen_Shot_2023-05-12_at_6.23.23_PM.png)

## Wrap up

In this lesson, we learned how to write a calculator in Clarity, including functions for addition, subtraction, multiplication, and division. We also learned how to test our code using ClarityTools. Congratulations on completing this lesson! With these skills, you are one step closer to becoming a Clarity expert. 

Next, we will learn how to steps our calculator code so stay tuned for the next lesson!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/3.%20Writing%20a%20Calculator%20in%20Clarity.md

Writing a Calculator in Clarity

# Prerequisites to Deploying Contract

Welcome back!  So we completed coding Calculator in Clarity. Awesome, you did great Well, get ready because in this lesson, we're going to learn how to deploy it!. Are you excited? Let's get started!

## What is Hiro wallet

Crypto wallets play a vital role for developers in testing dapps as they enable connectivity and transaction signing. Hiro wallet serves as a self-custody wallet where users have control over their keys. It is widely utilized within the Stacks ecosystem as a popular choice.

## Setting up Hiro wallet

- To get started, you can easily download the Hiro wallet as a Chrome/Brave extension by clicking [here](https://chrome.google.com/webstore/detail/hiro-wallet/ldinpeekobnhjjdofggfgjlcehhmanlj), or if you're using Firefox, you can download it from [here](https://addons.mozilla.org/en-US/firefox/addon/hiro-wallet/).

![Screen Shot 2023-05-15 at 5.28.37 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.28.37_AM.png)

- After downloading it, click on "Create new wallet".
    
    ![Screen Shot 2023-05-15 at 5.29.51 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.29.51_AM.png)
    
- Save your secret key and then click "I've backed it up".
    
    ![Screen Shot 2023-05-15 at 5.30.27 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.30.27_AM.png)
    
- Set a password for your Hiro account and click "Continue”.
- Now you will view a window like this 👇🏼
    
    ![Screen Shot 2023-05-15 at 5.33.09 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.33.09_AM.png)
    

- Click on the three dots icon in the top right corner and then click on "Change Network".

![Screen Shot 2023-05-15 at 5.33.35 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.33.35_AM.png)

- Change the network to **Testnet**. We will deploy our smart contracts to the testnet during development and testing.

![Screen Shot 2023-05-15 at 5.34.45 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.34.45_AM.png)

## Getting some tokens

Now, it's time to acquire some test STX tokens for you to deploy contracts on the Stacks blockchain and carry out transactions. Head over to [this](https://explorer.hiro.so/sandbox/faucet?chain=testnet) link, connect your wallet, and simply click on "Request STX" to get started.

![4.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/4.gif)

Under the Activity tab of your wallet, you'll soon notice that 500 STX tokens are on their way to you. Keep an eye out for the lightning sign, indicating that the transaction is currently pending. Rest assured that once a new block is mined (usually taking around 10-15 minutes), you'll receive those tokens as expected.

![Screen Shot 2023-05-15 at 5.42.23 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.42.23_AM.png)

After the next block is successfully mined, you'll witness that the STX tokens in your Balances tab has been added. 

![Screen Shot 2023-05-15 at 5.53.20 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.53.20_AM.png)

The lightning icon in the Activity tab will transform into the received icon. This change signifies that the tokens have been successfully received and added to your account.

![Screen Shot 2023-05-15 at 5.53.34 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Prerequisites%20to%20Deploying%20Contract%204dcbbec29cff4d7997f16a453b744c35/Screen_Shot_2023-05-15_at_5.53.34_AM.png)

## Wrap up

Congratulations on completing this lesson! You have learned how to set up a Hiro wallet, acquire test STX tokens, and set your network to the Stacks testnet. 

You're now fully prepared to engage with dapps on the Stacks blockchain and deploy your calculator contract to the Stacks testnet. It's time to dive in and start exploring the exciting possibilities that await you!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/4.%20Prerequisites%20to%20Deploying%20Contract.md

Prerequisites to Deploying Contract

# Deploying a Contract on Stacks

Welcome back!  So we completed coding Calculator in Clarity. Awesome, you did great! Well, get ready because in this lesson, we're going to learn how to deploy it! Are you excited? Let's get started!

## Clarity tools & deployment

You can head over to Clarity tools [link](https://clarity.tools/code/hello), and connect your Hiro wallet with it.

![1.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/Screen_Shot_2023-05-15_at_6.06.09_AM.png)

To deploy our contract, we have the option to use ClarityTools and select the "deploy contract" feature located in the toolbox at the top right corner. However, we won't be utilizing this method since it doesn't allow us to specify a specific name for our contract. Instead, ClarityTools assigns a random name to the smart contract automatically.

![Screen Shot 2023-05-15 at 6.06.09 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/Screen_Shot_2023-05-15_at_6.06.09_AM.png)

## Stacks Explorer Sandbox & deployment

Copy the complete code and head over to [Stacks Explorer Sandbox](https://explorer.stacks.co/sandbox/deploy?chain=testnet), a handy tool provided by Stacks Explorer. This tool enables us to interact with contracts and deploy them seamlessly.

So connect your wallet by clicking on the Connect Stacks Wallet button.

![2.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/2.gif)

Paste the entire code into the Stacks Explorer Sandbox and assign a name to your contract in the contract name field. Let’s name it "calculator".

![3.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/3.gif)

Click on the Deploy button and confirm the transaction in your wallet.

![4.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/4.gif)

Now copy your address from your Hiro wallet and search for it in the explorer.

![5.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/5.gif)

Once you initiate the deployment of the "calculator" smart contract, you will notice a pending transaction. It may take approximately 10-15 minutes for this transaction to be confirmed. Please be patient and wait for the confirmation to ensure the successful deployment of the contract.

## Interact with your contract

Once the transaction is confirmed, click on it and copy the contract name. This is your address and contract name.

![Screen Shot 2023-05-15 at 6.39.06 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/Screen_Shot_2023-05-15_at_6.39.06_AM.png)

Then head over to [Stacks Explorer Sandbox](https://explorer.stacks.co/sandbox/contract-call?chain=testnet) for interacting with contracts and paste your address and contract name in the input fields on left side. Then click Get Contract.

![Screen Shot 2023-05-15 at 6.35.41 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/Screen_Shot_2023-05-15_at_6.35.41_AM.png)

You can see the calculator contract that you just deployed! On the right side click on any of the functions of the contract to call them.

![Screen Shot 2023-05-15 at 6.42.53 AM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/Screen_Shot_2023-05-15_at_6.42.53_AM.png)

Call any function, enter values and it will return a response. Yayyyy!!!

![7.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/Deploying%20a%20Contract%20on%20Stacks%207b9f44b94e704a00bdd910f54aafad0c/7.gif)

## Wrap up

You've successfully learned how to deploy a contract and interact with it on Stacks network. Great job! Next, we will learn to write a BRC20 token and deploy it 🔥

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/2.%20Unleash%20the%20Power%20of%20Clarity%20Programming%20Language/5.%20Deploying%20a%20Contract%20on%20Stacks.md

Deploying a Contract on Stacks

Unleash the Power of Clarity Programming Language

Get Started with token in Stacks. Write your own BRC20 token and deploy and interact with it.

# Into the World of Tokens

Welcome back! So we completed coding and deploying Calculator on Stacks. Awesome, you did great! Well, in this lesson, we're going to learn about tokens! Are you excited? Let's get started!

## Tokens

Blockchain technology serves as a foundation for representing, storing, and exchanging value among users through digital assets known as blockchain tokens. These tokens can be owned and verified by individuals on the blockchain. They operate under predefined rules set either by the blockchain itself (native tokens) or through smart contracts within the blockchain ecosystem. Cryptocurrency is a prominent example of blockchain token usage, showcasing the potential of this technology in facilitating secure and transparent transactions.

## Tokens in Clarity

In Clarity, tokens can be either fungible or non-fungible. Fungible tokens are interchangeable and have the same value, while non-fungible tokens are unique and have different values.

### Fungible tokens

In the context of the Stacks blockchain, a fungible token refers to a digital asset that is interchangeable with other tokens of the same type. Each unit of the token is identical and holds the same value as any other unit. This allows for seamless and uniform transactions within the blockchain ecosystem.

To understand fungible tokens, let's consider the example of a concert ticket. Imagine you're organizing a music festival and decide to issue digital tokens as tickets on the Stacks blockchain. Each token represents admission to the event and holds the same value.

In this case, each concert ticket token is fungible, meaning they are all identical and can be freely exchanged with one another. It doesn't matter which token you hold; as long as it's a valid concert ticket token, it grants you entry to the event. You can easily transfer or trade your ticket with someone else without any impact on its value or functionality.

![concert-ticket.jpeg](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Into%20the%20World%20of%20Tokens%20e848e0b31edc4605ad27d589ef8f24df/concert-ticket.jpeg)

### Fungible Tokens on the Stacks blockchain

Fungible tokens on the Stacks blockchain operate similarly. They represent digital assets that can be exchanged, traded, or transferred among users without any distinction between individual tokens. Each token is considered equal in value and function, providing a seamless experience for transactions and interactions within the blockchain network.

Fungible tokens are often used for currencies, where one unit is the same as any other unit. In Clarity, fungible tokens can be created using the `fungible-token` library. This library provides functions for creating, transferring, and burning tokens.

### Non-Fungible tokens

In contrast to fungible tokens, non-fungible tokens (NFTs) on the Stacks blockchain represent unique and indivisible digital assets. Each NFT has distinct properties, making it different from any other token within the same collection. This uniqueness enables NFTs to represent one-of-a-kind items or digital assets in the blockchain ecosystem.

Continuing with our concert ticket example, let's imagine that instead of issuing fungible tokens, you decide to create non-fungible tokens to represent VIP passes for specific artists' meet-and-greet sessions at the music festival.

In this case, each VIP pass token is non-fungible, meaning it is unique and represents a specific opportunity to meet a particular artist. The tokens are distinguishable based on the artist, time slot, or other attributes associated with the meet-and-greet experience. Unlike fungible tokens, these VIP pass tokens cannot be freely exchanged with one another because each one holds different value and functionality.

![concert-ticket copy.jpeg](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Into%20the%20World%20of%20Tokens%20e848e0b31edc4605ad27d589ef8f24df/concert-ticket_copy.jpeg)

As an attendee, if you own an NFT representing a VIP pass for a meet-and-greet with your favorite artist, that token cannot be interchanged with someone else's token for a different artist. Each NFT has its own distinct value and purpose.

### Non-fungible Tokens on the Stacks blockchain

Non-fungible tokens on the Stacks blockchain work similarly by providing a means to represent unique digital assets, such as digital art, collectibles, or even real-world assets.

Non-fungible tokens are unique and cannot be interchanged. They are often used for representing assets like real estate, digital art, or collectibles. In Clarity, non-fungible tokens can be created using the `non-fungible-token` library. This library provides functions for creating, transferring, and burning non-fungible tokens.

## Wrap up

That's it for our lesson on tokens! We've learned about the two types of tokens in Clarity, fungible and non-fungible, and how they can be used to represent and exchange value on the blockchain. 

Next, we will learn how to code BRC20 token. 🔥

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/1.%20Into%20the%20World%20of%20Tokens.md

Into the World of Tokens

# Writing a BRC-20 token

Welcome back!  So we completed learning about tokens. Awesome, you did great! Well, get ready because in this lesson, we're going to learn how to write a BRC-20 token! Are you excited? Let's get started!

## BRC-20 token

A BRC-20 token is a kind of digital token that is fungible, meaning that each token is interchangeable and has the same value. BRC-20 tokens can be implemented using Clarity's built-in fungible token functionality. The code for a basic BRC-20 token contract includes functions for transferring tokens, minting new tokens, and retrieving token information such as the token name, symbol, and balance.

ERC20 tokens are developed by Ethereum and is a token standard for Ethereum network. On the other hand, BRC token is similar to ERC, it’s just that it’s deployed on bitcoin network so it’s called BRC. As **Stacks** is a Bitcoin layer for smart contracts, so we can make and deploy BRC token on Stacks.

In Clarity, traits are used to define the set of functions and constants that a contract needs to implement in order to conform to a specific interface or behavior. So fam, **Traits** in Clarity are super important to know so we can code BRC-20 token. So let’s learn about it.

## Traits

They are similar to templates for smart contracts. Traits consist of public function definitions that specify names, input types, and output types. Similar to Solidity's interfaces, traits provide a means to define a standardized set of functionalities that contracts can implement.

For example, we have a contract `contract-one` having a trait names `trait-old` and it is deployed on mainnet. Another contract `contract-two` can point to `contract-one.trait-old`. Traits are super important when it comes to making calls between different parts of a computer program.

### Define and implement trait

We can define and implement a trait as:

```
;; Define a trait
(define-trait adder
    (
        (add (uint uint) (response uint uint))
    )
)

;; Implement the trait
(define-read-only (add (a uint) (b uint))
;; return 
    (ok (+ a b))
)
```

In the above code, `ok` is a keyword used in Clarity to indicate that a function has executed successfully and to return a value from that function. It is commonly used in read-only functions, where the return value is not stored on the blockchain.

The `impl-trait`  is a function call that declares that the contract implements the trait named `adder` , for above example it would be:

```
impl-trait .adder-trait.adder
```

## Write code for BRC-20 token

Now go to the link of [Clarity Tools](https://clarity.tools/code/hello). Clear all the pre-written code and start writing the smart code there.

### Explanation

Let's start building the code line-by-line:

```
(impl-trait <insert-your-account-id>.contract-83714501649.sip-010-trait)
```

This line indicates that this code implements a trait. `contract-83714501649.sip-010-trait` is just name of the contract, so keep it as it is.

Replace `<insert-your-account-id>` with your Hiro’s wallet id.

![Screen Shot 2023-05-15 at 12.12.36 PM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Writing%20a%20BRC20%20token%20c88f4ac6801f40beb2e91e30d251a803/Screen_Shot_2023-05-15_at_12.12.36_PM.png)

```
(define-constant contract-owner tx-sender)

```

Here, we define a constant variable named `contract-owner` and assign it the value of the transaction sender. It represents the owner of the contract.

```
(define-constant err-owner-only (err u100))
(define-constant err-not-token-owner (err u101))
```

These lines define two error constants, `err-owner-only` and `err-not-token-owner`. These constants are used to represent specific error conditions that may occur during contract execution.

```
(define-fungible-token clarity-coin)
```

This line defines a fungible token named `clarity-coin`. 

```
(define-public (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))
    (begin
        (asserts! (is-eq tx-sender sender) err-not-token-owner)
        (try! (ft-transfer? clarity-coin amount sender recipient))
        (match memo to-print (print to-print) 0x)
        (ok true)))
```

Here, we define a public function named `transfer` that allows users to transfer tokens. It takes in the amount to be transferred, the sender and recipient addresses, and an optional memo. Inside the function, we perform several actions such as asserting that the transaction sender is the token owner, attempting to transfer the specified amount of tokens using the `ft-transfer` function, printing the memo if it is printable, and finally returning `true` to indicate a successful transfer.

```
(define-read-only (get-name)
    (ok "Clarity Coin"))
```

This function, `get-name`, is a read-only function that returns the name of the token, which in this case is `Clarity Coin`.

```
(define-read-only (get-symbol)
    (ok "CC"))
```

Similarly, the `get-symbol` function is a read-only function that returns the symbol of the token, which is `CC`.

```
(define-read-only (get-decimals)
    (ok u6))
```

The `get-decimals` function returns the number of decimal places for token balances, which in this case is represented by `u6`.

```
(define-read-only (get-balance (who principal))
    (ok (ft-get-balance clarity-coin who)))
```

This read-only function, `get-balance`, takes a principal address as an argument and returns the token balance of that address using the `ft-get-balance` function.

```
(define-read-only (get-total-supply)
    (ok (ft-get-supply clarity-coin)))
```

The `get-total-supply` function is a read-only function that returns the total token supply using the `ft-get-supply` function.

```
(define-read-only (get-token-uri)
    (ok none))
```

This function, `get-token-uri`, is a read-only function that returns the URI associated with the token. In this case, it returns `none` since there is no token URI defined.

## Complete code

The complete code is: 

```
(impl-trait 'ST13W323H99GMQD320C2VC6WTQG9TTK3JRV1N5AQR.contract-83714501649.sip-010-trait)

;; Defines a constant "contract-owner" and assigns it 
;; the value of the transaction sender.
(define-constant contract-owner tx-sender)

;; Defines an error constant "err-owner-only" with a 
;; value of "u100" (user-defined error code).
(define-constant err-owner-only (err u100))

;; Defines an error constant "err-not-token-owner" with 
;; a value of "u101" (user-defined error code).
(define-constant err-not-token-owner (err u101))

;; Defines a fungible token named "clarity-coin".
(define-fungible-token clarity-coin)

;; Defines a public function "transfer" for transferring tokens 
;; between senders and recipients.
(define-public (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))
    (begin
        ;; Checks if the transaction sender is the token owner; 
				;; otherwise, throws an error.
        (asserts! (is-eq tx-sender sender) err-not-token-owner)
        ;; Tries to transfer the specified amount of tokens from 
				;; the sender to the recipient.
        (try! (ft-transfer? clarity-coin amount sender recipient))
        ;; Matches the "memo" argument and prints it if it's a printable string.
        (match memo to-print (print to-print) 0x)
        ;; Returns "true" to indicate a successful transfer.
        (ok true)))

;; Defines a read-only function "get-name" to retrieve the name of the token.
(define-read-only (get-name)
    ;; Returns the name "Clarity Coin".
    (ok "Clarity Coin"))

;; Defines a read-only function "get-symbol" to retrieve the symbol of the token.
(define-read-only (get-symbol)
    ;; Returns the symbol "CC".
    (ok "CC"))

;; Defines a read-only function "get-decimals" to retrieve 
;; the decimal places for token balances.
(define-read-only (get-decimals)
    ;; Returns the number of decimal places as "u6".
    (ok u6))

;; Defines a read-only function "get-balance" to retrieve 
;; the token balance of a given principal.
(define-read-only (get-balance (who principal))
    ;; Returns the token balance for the specified principal.
    (ok (ft-get-balance clarity-coin who)))

;; Defines a read-only function "get-total-supply" to 
;; retrieve the total token supply.
(define-read-only (get-total-supply)
    ;; Returns the total token supply.
    (ok (ft-get-supply clarity-coin)))

;; Defines a read-only function "get-token-uri" to 
;; retrieve the URI associated with the token.
(define-read-only (get-token-uri)
    ;; Returns "none" as there is no token URI defined.
    (ok none))

;; Defines a public function "mint" to create new tokens 
;; and assign them to a recipient.
(define-public (mint (amount uint) (recipient principal))
    (begin
        ;; Checks if the transaction sender is the contract owner; 
				;; otherwise, throws an error.
        (asserts! (is-eq tx-sender contract-owner) err-owner-only)
        ;; Mints the specified amount of tokens and assigns 
				;; them to the recipient.
        (ft-mint? clarity-coin amount recipient)))
```

## Wrap up

In this lesson, we learned how to write a BRC-20 token in Clarity. We discussed the importance of traits and how they are similar to templates for smart contracts. We also went through the code line-by-line and explained how each function works. Finally, we provided the complete code for a basic BRC-20 token contract.

Now that we've learned about tokens and how to code them, we're ready to deploy and interact with them. Stay tuned for the next lesson!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/2.%20Writing%20a%20BRC20%20token.md

Writing a BRC20 Token

# Deploying and Interacting With BRC-20 Token

Welcome back!  So we completed learning about writing our first token contract. Awesome, you did great! Well, get ready because in this lesson, we're going to deploy and interact with BRC-20 token! Are you excited? Let's get started!

## Deploy the contract

Copy the complete code and head over to [Stacks Explorer Sandbox](https://explorer.stacks.co/sandbox/deploy?chain=testnet). Paste the code, name your contract and hit the Deploy button.

![Screen Shot 2023-05-15 at 1.41.12 PM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Deploying%20and%20Interacting%20With%20BRC20%20Token%207775a27d97b447a5b87637e65979c95f/Screen_Shot_2023-05-15_at_1.41.12_PM.png)

Hit the Confirm button and wait for 10-15 minutes for it be deployed.

![Screen Shot 2023-05-15 at 1.43.25 PM.png](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Deploying%20and%20Interacting%20With%20BRC20%20Token%207775a27d97b447a5b87637e65979c95f/Screen_Shot_2023-05-15_at_1.43.25_PM.png)

Once, it is deployed you will see a window similar to this:

![2.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Deploying%20and%20Interacting%20With%20BRC20%20Token%207775a27d97b447a5b87637e65979c95f/2.gif)

## Interact with your contract

After this, go to Available functions and interact with your desired functions:

![3.gif](https://github.com/0xmetaschool/Learning-Projects/raw/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/Deploying%20and%20Interacting%20With%20BRC20%20Token%207775a27d97b447a5b87637e65979c95f/3.gif)

## Wrap up

In this lesson, we learned how to deploy and interact with a BRC20 token. First, we deployed the contract by copying the code and pasting it into the Stacks Explorer Sandbox. After confirming the deployment, we waited for the contract to be deployed and then we were able to interact with it using the available functions. This was a great hands-on experience that will prepare you for working with tokens in the real world. Keep up the good work! 

Next, we will conclude our quick course.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/3.%20Let%E2%80%99s%20Start%20The%20More%20Fun%20Part/3.%20Deploying%20and%20Interacting%20With%20BRC-20%20Token.md

Deploying and Interacting With BRC20 Token

Let’s Start The More Fun Part

Let's wrap up the course and get an overview of what you learned in this course.

# Let’s Wrap It Up

Let’s wrap up our tutorial and go through what we learned in this tutorial.

## Understanding of Stacks Blockchain

You have learned the basic understanding of what Stacks Blockchain is, how it works, and why it is important in the blockchain space.

## Familiarity with Clarity

You have learned the basics of the Clarity programming language, its syntax, data types, visibility specifiers, and the ability to write simple smart contracts.

## Writing and Deploying a Smart Contract

You have gained the knowledge to write and deploy your own simple smart contract on the Stacks Blockchain using the ClarityTools and Stacks Explorer Sandbox.

## A Solid Foundation in Smart Contract Development

By understanding the basics of the Stacks Blockchain and Clarity, you have a solid foundation to continue exploring and developing smart contracts on the Stacks Blockchain.

## Writing and Deploying a BRC20 Token

You have gained the knowledge to write and deploy your own BRC20 Token on the Stacks Blockchain using the Clarity.

## 🎊 Congratulations

You have completed the tutorial and are now equipped with the foundational knowledge to start exploring the exciting world of blockchain and smart contract development on the Stacks Blockchain.

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Code%20a%20BRC-20%20token%20in%20Clarity%20on%20Stacks%20Blockchain%20I%20Metaschool/4.%20Let%E2%80%99s%20Wrap%20It%20Up/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Code a BRC-20 token in Clarity on Stacks Blockchain

Project Curriculum

Let’s Get Started

Unleash the Power of Clarity Programming Language

Let’s Start The More Fun Part

Let’s Wrap It Up

🎉 Completion

Get your NFT Image

Why metaschool?

NFT Certificates

Free of cost

Expert Trainer

Self Paced

Frequently asked questions