Learn how to create a fungible token on the Flow Blockchain. This is a comprehensive, step-by-step tutorial for beginners.. Start building your digital assets today!

If you’re a software engineer looking to add Flow Blockchain to your skillset, this is the place to start.

This course will teach you to write code and make an impactful token in Flow blockchain. The course will begin with a detailed introduction to Fl

Write Your First Smart Contract on Flow Blockchain

Learn prerequisites and learning outcomes of the course. Get started with the Flow blockchain.

# What Are We Building?

gm everyone 🌈, this is Munim from Metaschool. I am very excited to bring the very new exciting course for developers just like you, who want to bring the change in blockchain ecosystem!

So what are we building today? Today we’re gonna write a smart contract and a token on Flow Blockchain. YES, YOU HEARD IT RIGHT. I am going to introduce you to the exciting world of Flow Blockchain and give you a small glimpse of it.

Why Flow Blockchain? Because some of the biggest projects in web3 ecosystem [Cryptokitties](https://www.cryptokitties.co/), [NBA Top Shot](https://nbatopshot.com/), [NFL All Day](https://nflallday.com/), [Collab.land](https://www.collab.land/) etc are in the Flow Blockchain and Metaschool want you to get ahead of 90% developers.

Not only this, Flow has 11K active developers and over 20M user accounts. Yep! they are pretty dope and started the movement of crypto games on blockchain.

## Course overview

Together we will:

1. Learn everything about Flow Blockchain, smart contracts, and tokens.
2. Discover the _language_ the Flow Blockchain uses to do all the amazing stuff.

Not only this, I will teach you how you can write and deploy your own smart contracts and tokens on Flow Blockchain. Cool, right?!

## So, who exactly should take this course?

This course is for beginners web3 developers who wish to learn about the Flow blockchain and how they can create smart contracts using the.

## Prerequisites

Learning the Flow blockchain programming language will be much easier if you are familiar with Object-Oriented programming. Since programming language, the Flow Blockchain uses, is a high-level resource-oriented programming language, having OOP concepts will be very helpful.

**Don’t Worry!** I will teach you everything from scratch. So don’t get overwhelmed by reading the complicated concept like resource-oriented programming.

## 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 (1)](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/tree/b0030e3284018e8b7ce45c1f0981ac37d2f7fc21/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain). 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 Flow Blockchain course! Let's do this! 🙌


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Building%3F.md

What Are We Building?

# What is Flow Blockchain?

Hey guys, are you ready to get your minds blown? It's time to dive into the amazing world of the Flow blockchain!

Now, I know what you're thinking, "why should we care about this so much?" Trust me, you're gonna wanna stick around for this course. You're gonna learn all about how Flow works, why it's important, and how you can get involved in this revolutionary technology. Get ready to have your mind blown, because this is gonna be a wild ride!

## What the heck is a Flow blockchain?

First off, you're probably wondering, "what the heck is a Flow blockchain?" Well, let me tell you, it's this incredible system that makes digital transactions super fast and secure.

And Flow isn't just some fancy tech that only computer wizards can understand. It's actually used for all kinds of things, like buying and selling digital art, playing games, and even voting!

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/%F0%9F%91%80%20What%20is%20Flow%20Blockchain%20071990f9cc1e4160b14f9fb2bca10b73/flow.png?raw=true" alt="flow.com" width="70%" style="display: block; margin-left: auto; margin-right: auto;">

Well, for starters, it's way faster and easier to use than other blockchain platforms like Ethereum. Plus, it was created by the brilliant folks over at Dapper Labs, the same people who brought us iconic dApps like CryptoKitties and NBA Top Shot!

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/%F0%9F%91%80%20What%20is%20Flow%20Blockchain%20071990f9cc1e4160b14f9fb2bca10b73/Dapper_Labs.png?raw=true" alt="Dapper Labs" width="70%" style="display: block; margin-left: auto; margin-right: auto;">

With Flow, you can make all sorts of amazing decentralized apps that are gonna revolutionize the way you live and work.

## Flow network

Flow is a network that uses a fancy system (consensus mechanism) called "proof of stake" to make sure everything runs smoothly. To participate in the network, people called "validators" have to put in a specific number of tokens called "FLOW tokens". It's like putting some coins into a game before you can play. That way, everyone is invested in making sure everything works great!

## How does Flow work?

With Flow Blockchain, things work a little differently than other blockchains. Instead of just one type of node doing all the work, there are actually four different types of nodes that each have their own job.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/%F0%9F%91%80%20What%20is%20Flow%20Blockchain%20071990f9cc1e4160b14f9fb2bca10b73/1_I48vsDwbBK7zGukxIi9pFA.gif?raw=true" alt="Flow Work Flow" width="90%" style="display: block; margin-left: auto; margin-right: auto;">

We've got the consensus node, the verification node, the execution node, and the collection node. And get this, all four of these types of nodes work together to make sure every transaction is validated properly. Pretty cool, huh?

## What’s so special about Flow?

Flow Blockchain is perfect for creating cool, interactive crypto experiences that are becoming super popular these days. And the best part? These experiences can reach way more people in the future!

Just look at NBA Top Shot, which is a collectibles experience that uses Flow. It's already making crazy amounts of money and getting lots of attention from people who aren't even into crypto. And that's just one example of what Flow can do! There are gonna be tons of other awesome experiences coming our way soon. Get ready to be blown away!

## What can you do with Flow?

So if you want to start using Flow Blockchain, there are a few options for you. You can check out NBA Top Shot or VIV3 NFT marketplace and buy some cool artwork there. Or, you can try out some of the other apps that are already up and running on the blockchain.

As you're a developer, you're in luck! Flow has lots of built-in tools that you can use to start experimenting and creating your own dapps. So whether you're both a user and a developer, there are tons of ways to get involved with Flow and start exploring all the amazing possibilities it has to offer!

## Wrap up

In this course, I'll show you all the development tools you need to start experimenting and creating on the Flow blockchain.

And in the next lesson, I'll talk about something called "resource-oriented programming and architecture." It might sound fancy, but don't worry, I'll explain it all in a way that's easy to understand. After that, I'll dive into the programming language that Flow uses.

So buckle up and get ready for an awesome ride! You're gonna be a Flow Blockchain pro in no time! 🚀


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/2.%20What%20is%20Flow%20Blockchain.md

What is Flow Blockchain?

# Resource-Oriented Programming

Hey there, welcome back! In the last lesson, I talked about the basics of Flow Blockchain and why it's so cool.

Now, in this lesson, I'm gonna dive deeper into one of the most important parts (pillar) of Flow Blockchain: something called "resource-oriented programming." This is a key feature that sets Flow apart from other blockchains and helps it solve problems that other blockchains struggle with.

Before starting with the resource-oriented programming, let’s go through object-oriented programming that you are already familiar with. It will help you differentiate and learn faster. Let's go! 💪

## Object-oriented programming

Object-Oriented Programming (OOP) is all about organizing your code. Basically, with OOP, you create little "objects" that represent real-world things. These objects have properties (like color, size, etc.) and behaviors (like what they can do). And you can create different types of objects that share common characteristics.

## Resource-oriented programming

With Resource-Oriented Programming (ROP), you create your code around the resources that your program needs to interact with. These resources could be things like files, databases, or even web pages. By organizing your code this way, you can make sure your program runs smoothly and efficiently.

A resource is something important in your program that you need to manage and work with, like data or a service. It's like a unique identifier that helps you access and work with it easily.

Let's talk about resources and objects using a simple example.

## Understand difference between object and resource using real-world example

To understand the difference between resources and objects, let's use a library as an example. In a library, books can be both resources and objects.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/%F0%9F%92%A5%20Resource-Oriented%20Programming%20f179007d03944b64a3d8afa214168c72/books-g06a8f45d0_1280.png?raw=true" alt="Book Decks" width="70%" style="display: block; margin-left: auto; margin-right: auto;">

### Object

In Object-Oriented Programming (OOP), an object represents a specific instance of a class. In the context of our library example, an object could be a particular book like "Harry Potter and the Sorcerer's Stone." Objects have both data, like the author and publication year, and behavior, like borrowing and returning.

### Resource

However, in Resource-Oriented Programming (ROP), you focus on resources and their representation and manipulation. In the library example, the entire collection of books is the resource, while each individual book is an object within that resource.

To interact with the resource (the collection of books), you can use operations like retrieving, adding, updating, or removing books. In ROP, resources are typically accessed and manipulated using unique identifiers like a URL.

## ROP in Flow Blockchain

Okay, so when I talk about Flow, there are a few important parts to it. One of these parts is ROP, which actually defines how code should be structured in Flow and it helps represent digital ownership of assets on Flow.

To use ROP in the Flow blockchain, people use a special language called Cadence. In Cadence programming language, ROP works by creating objects that represent the resources you're working with.

### Resource example

For example, if you're working with a file in Cadence, you can create an object that represents that file and has methods for reading or writing to it. This makes it easier for you to work with the file in our code.

### Real-world example

For example, let's say you're building a web application in Cadence. You might have resources like web pages, APIs, and databases that you need to work with. By using ROP, you can create objects that represent each of these resources, and then use those objects to interact with them in your code. This makes it easier for you to build a scalable and maintainable web application that can handle lots of users and complex interactions.

## Wrap up

Awesome, you've got a good handle on the Flow blockchain and how it works! But there's so much more to explore, and I can't wait to dive into the next exciting topic: the Cadence programming language.

In the next lesson, you'll be learning all about how to use Cadence to write amazing code for the blockchain. Get ready for a deep dive into the world of programming and all the cool things you can do with it! 🙌


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/3.%20Resource-Oriented%20Programming.md

Resource-Oriented Programming

# What is Cadence?

Hey there, welcome back! Last time you had a blast learning about resource-oriented programming (ROP) and how it's used in the Cadence programming language. I even compared it to another programming model called object-oriented programming (OOP)!

Now, are you ready to get even more pumped up? In this lesson, you're going to go all-in on Cadence programming language and explore all its amazing features. Get ready to take your programming skills to the next level! 💪

## What is Cadence?

So when people want to create apps for the Flow blockchain, they use a programming language called Cadence to go with super-fast and efficient blockchain.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/%F0%9F%91%80%20What%20is%20Cadence%20ccc004db78e74b49b88b94453994a275/Cadence_Logo.png?raw=true" alt="Cadence" width="70%" style="display: block; margin-left: auto; margin-right: auto;">

Using Cadence makes it easier for developers to write code that works well on the Flow network. So, if you're interested in making your own apps for the blockchain, Cadence is definitely something you'll want to check out!

## Why use Cadence?

One of the really neat things about Cadence is that it's the first high-level, resource-oriented programming language out there. That just means it's really good at helping you work with resources in your code - like digital assets on the Flow blockchain, for example.

### Cadence resources

The resources in Cadence are really cool because they're based on linear data types, which means they can only exist in one place at a time. So, if you own an NFT (which is a type of digital asset), that NFT is stored directly in your account and can't be duplicated or copied somewhere else.

### Cadence security

Resources are really important because it means that the ownership of digital assets on Flow is defined directly in the Cadence language itself, which helps to remove the risks that can come with storing balances on a centralized digital ledger. It's kind of like having a really secure, tamper-proof safe for your digital assets!

### Final thoughts

So, if you're interested in working with digital assets on the Flow blockchain, Cadence is definitely the way to go. Its resource-oriented programming language makes it easy to work with these assets and ensure their ownership is secure and protected.

## Cadence Features

Cadence is built on pillars and here are those five pillars:

- **Safety and security:** Cadence ensure smart contracts are secure and only accessible to authorized parties.
- **Clarity:** The way Cadence is written makes it easy to understand what the code is doing, which makes it easier to write, read, and check for errors.
- **Approachability:** Cadence's syntax and structure are based on popular programming languages like Swift and Rust, so it's easy for developers to get started with it. Plus, there are lots of resources available to help them learn more and troubleshoot any issues they may run into.
- **Developer experience:** The Flow ecosystem provides support and resources to developers throughout the entire development process, from start to finish.
- **Intuitive ownership with resources:** Cadence's use of resources means that asset ownership is built right into the code itself. This means assets are tied to specific accounts and can be transferred without the need for a smart contract.

## Wrap up

You've made it so far, and you're already a blockchain expert! You learned all about the Flow Blockchain, resource-oriented programming, and even got a taste of the amazing Cadence programming language and its cool features!

Now, it's time to kick it up a notch and dive headfirst into Cadence programming language.

You're going to learn all the basics and start coding in the Flow blockchain. Are you excited? I sure am!

Don't give up now, keep pushing through and soon you'll be writing awesome code! You got this, let's go! 🚀


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/1.%20Let%E2%80%99s%20Get%20Started/4.%20What%20is%20Cadence.md

What is Cadence?

Let’s Get Started

Get started with Cadence programming language and learn the basic concepts.

# Cadence Basics - I

Welcome back! 🎉 Remember what I talked about in the last lesson? You learned about Cadence and how it works. Well, get ready because in this lesson, you're going to dive into the fun part - coding in Cadence! You'll explore composite types and contracts. You’ll learn how contracts work and learn about their basic structure. Are you excited? Let's get started!

## Composite types in Cadence

Composite types are like building blocks that let you combine simpler types to create more complex ones. There are two types of Composite types in Cadence.

1. `resource`: Resource can only be used exactly once.
2. `struct`: One Struct can have different objects just like in C++ or GoLang.

### Composite type declaration

Let’s look at how you can declare a `resource` and `struct`.

**Resource**

You can declare a resource using `resource` keyword.

```
<visibilitySpecifier> resource ResourceName {
			// ...
}
```

**Struct**

You can declare a structure using `struct` keyword.

```
<visibilitySpecifier> struct StructName {
			// ...
}
```

> **Note:** Visibility specifiers defines who can access the type it has been written with. It defines whether the resource, struct, contract, variable, or function is public or private. If you don’t write any visibility specifier with the type it means that type is private by default.

### Composite type creation

Now let’s look at how you can create a `resource` and `struct`.

> **Note:** Remember that both structures and resources are types.

**Resource**

You can create and instantiate a `resource` using `<-`sign and`create` keyword.

```
// instantiate a new resource object and assign it to a constant
let constantName <- create SomeResource()
```

> **Don’t Worry!** You will go through the constants in the next lesson. Let’s just focus on resource and struct for now.

**Struct**

You can create and instantiate a `struct` by calling the type just like functions.

```
/ instantiate a new struct object and assign it to a constant
let constantName = StructName()
```

> **Fun fact:** Composite types can only be declared within a contract and nowhere else.

### What can composite types hold in Cadence?

Both structures and resources can hold the following data.

- Variables of various types (e.g. String, Int, Array, Dictionary)
- Public and private functions
- Access control to ensure that only authorized parties can modify the composite types
- Constructors

## What is a contract in Cadence?

In Cadence, a contract is like a recipe that tells the Flow blockchain how a digital asset should behave and what state it should be in. Think of it as a blueprint for something like a special token or a cool NFT that you want to create.

### Basic contract structure

Here is how the basic structure of the definition of contract in Cadence looks like.

```
<visibilitySpecifier> contract ContractName {
			//...
}
```

A `contract` keyword is used to define the contract in Cadence. It will be necessary to use, wherever you want to create a smart contract in Cadence.

Here is an example of basic Cadence contract:

![Screenshot 2023-05-11 at 6.44.31 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%92%BB%20Cadence%20Basics%20-%20I%20b81051fb047d4a85bb95af94c74de0d2/Screenshot_2023-05-11_at_6.44.31_PM.png?raw=true)

### What can a simple contract hold in cadence?

A simple contract in Cadence can additionally hold composite types, both structures and resources along with all the data, composite types can hold.

## What is an interface in Cadence?

Do you know what an interface is? 🤔 It's like a blueprint for how different types of things should behave. For example, let's say you have a bunch of different types of animals, and you want them all to be able to make a sound. You could create an interface that says "any animal that implements this interface must have a function that makes a sound."

Interfaces also set rules for what kind of information and how much of it different types need to provide. It's like saying "if you want to be part of this group, you have to meet these specific requirements."

So, an interface is just a way to make sure that different types of things all behave the way they're supposed to. It's kind of like setting up a code of conduct!

There are three types of interfaces:

- **Structure interfaces**: implemented by structures
- **Resource interfaces**: implemented by resources
- **Contract interfaces**: implemented by contracts

### Interfaces declaration

Interfaces are declared using `resource`, `struct`, or `contract` keyword followed by `interface` keyword along with the visibility specifier and the name of interface.

![Screenshot 2023-05-15 at 11.00.59 AM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%92%BB%20Cadence%20Basics%20-%20I%20b81051fb047d4a85bb95af94c74de0d2/Screenshot_2023-05-15_at_11.00.59_AM.png?raw=true)

### What can interface hold in Cadence?

Interfaces consist of the function and field requirements.

**Function requirements**

When I talk about function requirements, it's basically what a function needs to have. This includes the function's name, the types of parameters it takes, and optionally what it returns. It can also have some extra conditions called preconditions and postconditions if necessary. These conditions help specify what needs to happen before and after the function runs.

**Field requirements**

Now, let's talk about field requirements. Fields are like variables that belong to a certain object or type. When I talk about field requirements, it means I'm specifying what a field should have. This includes the field's name and its type. Additionally, you can also add some extra requirements for getting and setting values to that field. These requirements can have their own preconditions and postconditions, which set some conditions that need to be met before and after getting or setting a value.

So, it's all about setting up the necessary conditions for functions and fields to make sure everything works smoothly!

## Wrap up

With simple and easy-to-understand code and lots of tools to work with, you can create all sorts of awesome decentralized apps and smart contracts. The possibilities are endless!

Get ready for the next lesson! You're going to dive deep into Cadence and cover everything from visibility specifiers to control flows. You're going to master it all! Don't lose your motivation now – you've got this! 👍


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/1.%20Cadence%20Basics%20-%20I.md

Cadence Basics - I

# Cadence Basics - II

In the last lesson, you learned about contracts and their important role in defining digital assets on the Flow blockchain network. But did you know that in Cadence, contracts hold all the code, structures, resources, variables, functions, and constructors for a specific asset? That's right, you can't write variables or functions independently outside of a contract, resource, or struct.

But don't worry, in this lesson, you'll dive into the basics of Cadence and show you how to work with variables and functions along with other important features! Get ready to unleash your coding skills! 🚀

## Visibility specifiers

Visibility specifiers in Cadence control the accessibility of structures, resources, contracts, variables, and functions. There are following visibility specifiers in Cadence.

- **`pub` / `access(all)`**: a contract, variable, or function that can be accessed from other accounts or contracts on the Flow blockchain.
- **`priv` / `access(self)`**: a contract, variable, or function that can only be accessed within the scope where it is declared.
- **`access(account)`:** a contract, variable, or function that can be accessed anywhere within the same account it is deployed to (other contracts in the same account can access it).
- **`access(contract)`:** a contract, variable, or function that can be accessed anywhere within the same contract it is deployed to (other contracts cannot access it).

## Data Types

Data types in Cadence define the type of value that a variable can hold. Some of the Cadence data types are as follows:

- **`String`**: Use to define a sequence of characters
- **`Int`**: Use to define an integer value
- **`Bool`**: Use to define a boolean value (`true` or `false`)
- **`Address`**: Use to define an account address on the Flow blockchain

## Constructor

In Cadence, you can declare the constructor using `init` keyword inside the resource, struct, or contract. The basic syntax of a constructor in Cadence is as follows:

```
init() {
		// constructor code goes here
}
```

You can also pass parameters to the `init` as per needed.

> **Note:** Constructors are mostly used to initialize the variables with initial values.

## Composite type fields

In Cadence, there are two kind of fields: variables and constants. You can only initialize the fields with initial values in the initializer (`init`) and not in the field declaration.

Let’s look at how two fields can be declared and when to change their values.

- **Constants**
  - Constants can be declared using `let` keyword.
  - Once you initialize the constant inside of the initializer (`init`) you cannot change its value later.
  - A constant field must be initialized exactly once.
- **Variables**
  - Variables can be declared using `var` keyword.
  - Once you initialize the variable inside of the initializer (`init`) you can change its value later.

> **Note:** In initializers, the special constant `self` is used to refer to variables and constant those were declared inside the resource, struct, or contract.

## Constants

Constants in Cadence are declared using `let` keyword. The basic syntax of declaring a constant is as follows:

```
<visibilitySpecifier> let variableName: dataType
```

> **Note:** Visibility specifier is optional. If no visibility specifier is defined with constant, it means the constant is private by default.

### Example

Here is the constant declaration example in Cadence:

![Screenshot 2023-05-11 at 9.10.28 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%A4%AF%20Cadence%20Basics%20-%20II%205bbeaef043ee4e2fafcb4d0c9690e303/Screenshot_2023-05-11_at_9.10.28_PM.png?raw=true)

This is how you can intialize the above variable in a constructor.

```
self.greetings = "Hello"
```

> **Note:** The variables follow the same pattern for declaration and intialization, only difference is you can make changes in the variable after the initial intialization.

## Functions

You can declare functions in Cadence using the `fun` keyword just like you declare the functions in Solidity using `function` keyword. The basic syntax of a function in Cadence is as follows:

```
<visibilitySpecifier> fun functionName(<VariableName: DataType>): ReturnType {
    // Code block
}
```

- The visibility specifier is optional with function defination. If no visibility specifier is defined with function, it means the function is private by default.
- Parameters to the functions are also optional.

### Example

Here is the function example in Cadence:

![Screenshot 2023-05-11 at 7.58.15 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%A4%AF%20Cadence%20Basics%20-%20II%205bbeaef043ee4e2fafcb4d0c9690e303/Screenshot_2023-05-11_at_7.58.15_PM.png?raw=true)

## Comments

Comments in Cadence are used to document code and improve its readability.

### Single-line comment example:

```
// This is a comment
```

### Multi-line comment example:

```
/*
This is a multi-line comment
It can span multiple lines
*/
```

## Control flow

Control flow statements in Cadence allow a program to make decisions based on conditions and repeat code until certain conditions are met. Following are some of the control flow statements examples.

### if-else statement example

```
if x > 0 {
    // Code to run if x is greater than 0
} else {
    // Code to run if x is less than or equal to 0
}
```

### while loop example

```
while x > 0 {
    // Code to repeat while x is greater than 0
    x -= 1
}
```

### for loop example

```
for i in 0...10 {
    // Code to repeat for each value of i from 0 to 10 (inclusive)
}
```

## Wrap up

Awesome! Now that you've learned the basics of Cadence programming, you're ready to create amazing smart contracts and digital assets on the Flow blockchain network. By mastering these concepts, you'll have the power to build even more complex applications that can transform the future of technology!

Now, get ready for an exciting ride in the next lesson! You'll be putting all the knowledge you've gained so far into action and writing a complete contract. With your newfound skills, you'll be able to create amazing applications on the Flow blockchain network. So, hold on tight and let's get started! 🚀


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/2.%20Cadence%20Basics%20-%20II.md

Cadence Basics - II

# Write and Deploy Your First Cadence Program

Hey there! So in the past two lessons, you got a good grasp of the basics of Cadence. But get ready for the fun part! In this lesson, you get to put your knowledge to the test and create a complete smart contract. You'll have the chance to deploy your smart contract using the Flow Playground. Let's get started!

## Writing the code

Let's start by writing the code for the `Greeting` smart contract.

```
// Greeting.cdc
pub contract Greeting {
    pub let greeting: String

    init() {
        self.greeting = "Welcome to Metaschool!"
    }

    pub fun sayWelcome(): String {
        return self.greeting
    }
}
```

Alright, hold up for a second! Before you jump into deploying your smart contract, let's explore what the Flow Playground is all about.

## What is Flow Playground?

Flow Playground is like a super cool web tool that lets developers create and test their own smart contracts right from their computer! With it, you can write, deploy, and play around with smart contracts on the Flow blockchain, all in one place.

This is how the Flow Playground looks like:

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%9A%80%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program%202b398ce82b784a50b2c3495ea5fa4249/Untitled.png?raw=true)

## What is an account in Flow Blockchain?

An account is like your very own space on the Flow blockchain. It's where you can store your digital assets, and it's protected by your own special code, called a public and private key pair. Think of it like your own personal locker at the gym! To access anything on the Flow blockchain, you need an account, and each account has a unique address to identify it.

Check out the awesome accounts section in the Flow Playground!

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%9A%80%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program%202b398ce82b784a50b2c3495ea5fa4249/Untitled%201.png?raw=true" alt="Accounts" width="70%" style="display: block; margin-left: auto; margin-right: auto;">

> **Note:** `0x01`, `0x02`, `0x03`… represents the unique address of each account.

## Deploying a Smart Contract using Flow Playground

Now, let's deploy your `Greeting` smart contract using the Flow Playground.

### Navigate to the Flow Playground

First, navigate to the Flow Playground website at **[https://play.onflow.org/](https://play.onflow.org/)**.

### Copy-paste smart contract

In the `Contract 1.cdc`, copy and paste the following code `Greeting` smart contract.

```
// Greeting.cdc
pub contract Greeting {
    pub let greeting: String

    init() {
        self.greeting = "Welcome to Metaschool!"
    }

    pub fun sayWelcome(): String {
        return self.greeting
    }
}
```

### Edit name

In the `Contract` folder at sidebar, click on three dots in front of `Contract 1` and “Edit name”. Give your contract a name, such as "HelloWorld".

![edit-name.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%9A%80%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program%202b398ce82b784a50b2c3495ea5fa4249/edit-name.gif?raw=true)

### Deploy smart contract

Open “Log” at the right bottom of the Playground page and click on the "Deploy" button to deploy your smart contract to the Flow blockchain.

![deploy.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%9A%80%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program%202b398ce82b784a50b2c3495ea5fa4249/deploy.gif?raw=true)

The “Log” will show you the following output.

![Untitled](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%9A%80%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program%202b398ce82b784a50b2c3495ea5fa4249/Untitled%202.png?raw=true)

The **`0x01`** represents the address of the account, the smart contract is deployed to.

## Run your smart contract

So far you have just deployed the smart contract. To run the smart contract and see the output head over the “Transaction” at side bar. You will see something like this already written in the Transaction file:

```
import HelloWorld from 0x01

transaction {

  prepare(acct: AuthAccount) {}

  execute {
    log(HelloWorld.hello())
  }
}
```

Replace `HelloWorld` with `Greeting` and `hello` with `sayWelcome`. After making the changes click on “Send” and see the output of your Greeting contract in the “Logs” section.

Let’s see this happening live.

![run contract.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/%F0%9F%9A%80%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program%202b398ce82b784a50b2c3495ea5fa4249/run_contract.gif?raw=true)

Did you notice how “Error” section helped resolve the errors? You can this section to debug your code and resolve any error you might face.

# Wrap up

Wow, great job on learning the basics of Flow and Cadence! You now have the knowledge to write your own smart contracts and deploy them on Flow Playground. But wait, there's more! In the next section of the course, you'll be exploring the exciting world of tokens in the Flow blockchain. Get ready to learn about Token Standards in Flow and even create your very own token. Keep up the good work! 👍


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/2.%20Unleash%20the%20Power%20of%20Cadence%20Programming%20Languag/3.%20Write%20and%20Deploy%20Your%20First%20Cadence%20Program.md

Write and Deploy Your First Cadence Program

Unleash the Power of Cadence Programming Language

Get started with Flow token standards and learn how to create your first token on Flow.

# Let’s Get Started With Tokens

Awesome job for coming so far! You've got the basics of Flow and Cadence down. But now, it's time to take things up a notch and jump into the world of tokens!

In this section of the course, we'll show you everything you need to know about tokens, including the different types of tokens that exist in the crypto world. You'll also learn about token standards in the Flow blockchain, which will help you create your own tokens with ease.

So, buckle up and get ready for an exciting ride!

## What exactly the tokens are

Tokens are super cool digital objects that represent something valuable! They can be used for buying things, playing games, or accessing certain online services. It's like having digital coins or tickets in your virtual wallet!

### Example

For example, imagine that you're at a carnival and you want to ride on the Ferris wheel. You'll need to buy a ticket first, which represents the value of the ride. Without the ticket, you can't go on the Ferris wheel. Just like that, digital tokens can represent different types of value, such as money or access to certain services.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/%F0%9F%92%B8%20Let%E2%80%99s%20Get%20Started%20With%20Tokens%2083a592c9659243fd97c10efeeb175c95/circus-ga69234675_640.png?raw=true" alt="Circus" width="70%" style="display: block; margin-left: auto; margin-right: auto;">

In a video game, tokens can be used to buy items for your character. They act as a virtual currency that you can use within the game to purchase different things. Although these tokens have value within the game, they can't be used outside of it.

## Different kind of tokens

Let’s learn what are the different types of tokens using real-world example to make you understand each token easily.

## Fungible Token

Let’s explain Fungible Tokens by comparing them to candy.

Think of it like a bag of candy bars - all the candy bars are exactly the same, and you can trade one for another without any difference. Each candy bar is worth the same amount, and you can exchange them for something else of equal value.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/%F0%9F%92%B8%20Let%E2%80%99s%20Get%20Started%20With%20Tokens%2083a592c9659243fd97c10efeeb175c95/candy-gfaa1441da_640.png?raw=true" alt="Candy" width="150" style="display: block; margin-left: auto; margin-right: auto;">

Similarly, there are digital tokens that are also fungible, like "Star Coins" in a video game. Each Star Coin is worth the same amount as all the others, and you can use them to buy things in the game. You could trade one Star Coin for another, and it wouldn't make any difference.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/%F0%9F%92%B8%20Let%E2%80%99s%20Get%20Started%20With%20Tokens%2083a592c9659243fd97c10efeeb175c95/joystick-g88179f6eb_640.png?raw=true" alt="Joy Stick" width="45%" style="display: block; margin-left: auto; margin-right: auto;">

So, a fungible token is something that can be exchanged for something else of equal value, just like candy bars or Star Coins. It's called "fungible" because all the tokens are the same, and you can't tell them apart.

## Non-Fungible Token

Let’s expand our candy analogy to Non-Fungible Tokens now.

Imagine owning a collection of unique candy treats called "Magical Candy Friends." Each candy friend has its own special features, like Lollipop Larry with a swirl design and cherry flavor, and Bubblegum Bella, a round candy friend with a bubblegum flavor. Unlike regular candy bars, these Magical Candy Friends are one-of-a-kind and can't be directly exchanged for another. They have individual value and characteristics that make them special. Similarly, NFTs (non-fungible tokens) are unique and can't be swapped with other NFTs on a one-to-one basis.

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/%F0%9F%92%B8%20Let%E2%80%99s%20Get%20Started%20With%20Tokens%2083a592c9659243fd97c10efeeb175c95/cartoon-g1c10b5e1d_640.png?raw=true" alt="Candy Treats" width="40%" style="display: block; margin-left: auto; margin-right: auto;">

Digital tokens can be non-fungible too - just like a rare Pokémon card in a card deck! It's the only card of its kind in the game, so you can't trade it for another one and expect it to be the same. That's because it's unique and special!

<img src="https://github.com/0xmetaschool/Learning-Projects/blob/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/%F0%9F%92%B8%20Let%E2%80%99s%20Get%20Started%20With%20Tokens%2083a592c9659243fd97c10efeeb175c95/pixel-gfcc3f1ca9_640.png?raw=true" alt="Pokemon" width="50%" style="display: block; margin-left: auto; margin-right: auto;">

So, a non-fungible token is something that's rare and unique, and you can't swap it out for something else of equal value. It's called "non-fungible" because it's different from other tokens, and you can tell them apart easily!

## Tokens and Flow blockchain

Tokens on the blockchain are digital representations of all kinds of assets - from cryptocurrencies to digital collectibles and beyond! And on Flow, a powerful blockchain platform, you can create and manage your own tokens and smart contracts.

## What are Flow Token Standards?

Flow has its own set of token standards that define how these tokens can be created, managed, and exchanged on the platform. This means that you have all the tools you need to create unique and valuable digital assets that can be easily traded and managed on the Flow blockchain.

As you're a developer, you can use these cool rules and guidelines to create tokens on the Flow blockchain, and make sure they're compatible with other apps and wallets on the network. It's like having a secret code to unlock all the potential of the Flow platform!

So, what are these magical standards? There are actually two of them: **the Fungible Token Standard** and **the Non-Fungible Token Standard**. Each one has its own unique features and benefits, and they can be used to create all sorts of amazing digital assets, from cryptocurrencies to rare collectibles.

## Wrap up

By using the Flow token standards, developers can create tokens that are secure, reliable, and interoperable with other apps and services on the platform. And who knows? Your token might just be the next big thing in the blockchain world!

Get ready, because in the next lesson we're diving deep into the world of Fungible Token Standards! We'll explore how these standards work by checking out the coding part that defines the rules for creating Fungible Tokens on the Flow blockchain. It's going to be an awesome learning experience! 🌟


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/1.%20Let%E2%80%99s%20Get%20Started%20With%20Tokens.md

Let’s Get Started With Tokens

# Let’s Talk About Fungible Token Standard

Hey there! In the last lesson, we talked about tokens and Flow Token Standards. Now get ready for the next level! In this lesson, we're going to learn about Fungible Tokens – what they are, how they work, and specifically how they work in Cadence. Get excited, because this is where things start to get really interesting!

## Flow ecosystem

In the Flow community, we use Flow Fungible Tokens for digital currencies, rewards, and loyalty points. They make it super simple for people to transfer and exchange with each other. Plus, they're a breeze for developers to use when building token-based systems on the Flow blockchain. So let's get ready to explore all the exciting possibilities of Flow Fungible Tokens!

## The Flow Fungible Token Standard

The Flow Fungible Token Standard consist of a contract interface called `FungibleToken` . The `FungibleToken` standard requires contracts to define a `Vault` resource that represents an account's owned tokens. Each account that has tokens has a corresponding `Vault` stored in its account storage. To send or receive tokens, users call functions on each other's Vaults.

Now, let’s explore this one-by-one in detail, learn how each part of the standard works and explore the basic coding structure of the Fungible Token Standard.

### `FungibleToken` contract interface

The FungibleToken contract interface is a set of rules that all Fungible Token contracts must follow. When someone wants to create a new token contract, their contract must implement this interface. It ensures that the contract adheres to the specified rules and naming conventions, making token contracts work consistently and predictably.

In a nutshell, the FungibleToken interface acts as a guidebook for token contracts, ensuring they play by the rules. By implementing the interface, the contract agrees to follow the defined standards, allowing for seamless compatibility among different token contracts.

Let’s look at how you can declare the `FungibleToken` contract interface in Cadence.

```
pub contract interface FungibleToken {

	// The FungibleToken hold following functionalities:
	// Resources
	//  Resource Interfaces
	// Field Requirements
	// Functions

}
```

### `Vault` resource

So, if you have tokens, you'll need a special thing called a Vault resource. Every account that owns tokens should have one stored in their account storage. It's like having a safe place to keep your tokens secure!

The cool thing about the Vault resource is that it has methods that you and others can use to interact with your token balance. It's like having a set of tools to manage and do stuff with your tokens!

Inside the Vault resource, your token balance is stored as a fixed-point number, which is just a fancy way of representing numbers. It uses the `UFix64` type, which is like a specific format for keeping track of your token balance.

Here's a basic example of what a `Vault` resource might look like in Cadence:

```
// Defining the Vault resource interface
pub resource Vault {

    // The balance is represented as a fixed-point number using UFix64 type
    pub var balance: UFix64

    // Defining the withdraw function to withdraw tokens from the Vault
    pub fun withdraw(amount: UFix64): @Vault

    // Defining the deposit function to deposit tokens into the Vault
    pub fun deposit(vault: @Vault): @Vault
}
```

### `Provider`, `Receiver`, and `Balance` resource interfaces

We have three cool resource interfaces: the `Provider`, `Receiver`, and `Balance`. These interfaces set some rules for the functions in the Vault. They have pre-conditions and post-conditions that control how these functions can be executed. It's like having some guidelines to follow when using the Vault!

The reason these interfaces are separate is pretty neat! It's because they allow users to share their `Vault` reference in a specific way. They can choose to expose only certain fields and functions by implementing one or more of these interfaces. It's like having different levels of access for different users.

Not only that, but these interfaces also give users the flexibility to create their own custom resources. They can make something cool and unique by implementing these interfaces. For example, if someone wants to create a faucet, they can conform to the `Provider` interface. It's like having the power to create different functionalities with tokens!

Here's a basic example of what these interfaces might look like in Cadence:

```
// Defining the Provider resource interface
pub resource interface Provider {
    // Defining the provideTokens function to provide tokens to the recipient
    pub fun provideTokens(recipient: @Receiver, amount: UFix64)
}

// Defining the Receiver resource interface
pub resource interface Receiver {
    // Defining the receiveTokens function to receive tokens from the provider
    pub fun receiveTokens(provider: @Provider, amount: UFix64)
}

// Defining the Balance resource interface
pub resource interface Balance {
    // Define the getBalance function to get the balance of the specified account
    pub fun getBalance(account: Address): UFix64
}
```

> **Don’t Worry!** We will look at the practical example of Flow Fungible Token Standard in detail in the next lesson.

## Wrap up

You can send and receive tokens using resources and interfaces in Fungible Token contracts. It's all about making peer-to-peer transactions super easy and without any need for a central ledger smart contract.

To send tokens to another user, it's as simple as two steps! First, you'll withdraw the tokens from your Vault. It's like taking them out of your personal safe. Then, you'll call the deposit function on the other user's Vault. It's like handing over the tokens to their safe. And ta-da! The transfer is complete!

By using this process, you can send tokens directly to another user without any intermediaries. It's like having a direct connection to transfer tokens securely and efficiently. No hassle, no central authority involved!

So, it's all about withdrawing from your Vault and depositing into the other user's Vault to make seamless peer-to-peer token transfers. Easy peasy!

Get ready for an exciting adventure! 🚀 In the next part, we'll dive into creating your own Flow fungible token using the standards we covered. It's time to unleash your creativity and leave your mark in the digital world. So gear up and get ready to embark on this thrilling journey! Let's make your very own token and make things awesome!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/2.%20Let%E2%80%99s%20Talk%20About%20Fungible%20Token%20Standard.md

Let’s Talk About Fungible Token Standard

# Create Your First Flow Token - I

Get ready to level up your skills! In the last lesson, you explored the basic structure of the **`FungibleToken`** contract interface in Cadence. Now, get ready to dive even deeper!

You're about to embark on an exciting journey of implementing the `FungibleToken` contract interface, line by line. Together, we'll bring this powerful interface to life through code and unlock its full potential. Are you ready for this epic coding adventure? Let's go!

## Defining the `FungibleToken` interface

Let’s define the basic structure of `FungibleToken` interface first.

```
pub contract interface FungibleToken {

		/* Field requirements */

    pub var totalSupply: UFix64

    pub event TokensInitialized(initialSupply: UFix64)

    pub event TokensWithdrawn(amount: UFix64, from: Address?)

    pub event TokensDeposited(amount: UFix64, to: Address?)

		/* Interface, resource, and functions requirements */

		// Provider resource interface declaration
    pub resource interface Provider {
				// Provider code goes here
    }

		// Receiver resource interface declaration
    pub resource interface Receiver {
				// Receiver code goes here
    }

		// Balance resource interface declaration
    pub resource interface Balance {
				// Balance code goes here
    }

		// Vault resource declaration that further implements
		// Provider, Receiver, Balance resource interfaces
    pub resource Vault: Provider, Receiver, Balance {
		    // Vault code goes here
    }

    pub fun createEmptyVault(): @Vault {
				// createEmptyVault() code goes here
    }
}
```

Let’s go through the requirement fields you declared at the start of the contract.

```
pub contract interface FungibleToken
```

- This line of code declares a public contract interface named `FungibleToken`.
- An interface is like a blueprint that defines the methods and properties that a smart contract must implement to comply with this interface.

```
pub var totalSupply: UFix64
```

- This line declares a public variable named `totalSupply` with a `UFix64` data type.
- The `totalSupply` holds the total number of tokens that exist for the `FungibleToken` smart contract.
- It is up to the developer to ensure that the `totalSupply` stays accurate and up to date.

```
pub event TokensInitialized(initialSupply: UFix64)
```

- This line declares a public event named `TokensInitialized`, which takes an argument `initialSupply` of type `UFix64`.
- This event is emitted when tokens are initially supplied to the smart contract, i.e., the event is emitted when the contract is created.

```
pub event TokensWithdrawn(amount: UFix64, from: Address?)
```

- This line declares a public event named `TokensWithdrawn`, which takes two arguments: `amount` of type `UFix64` and `to` of type `Address`.
- This event is emitted when tokens are withdrawn from the Vault.

```
pub event TokensDeposited(amount: UFix64, to: Address?)
```

- This line declares a public event named `TokensDeposited`, which takes two arguments: `amount` of type `UFix64` and `to` of type `Address`.
- This event is emitted when tokens are deposited into the Vault.

## Implementing the `Provider` interface

Let’s look at the implementation of `Provider` interface.

```
pub resource interface Provider {

	 pub fun withdraw(amount: UFix64): @Vault {
	      post {
	          result.balance == amount:
	          "Withdrawal amount must be the same as the balance of the withdrawn Vault"
	      }
	  }
}
```

Let’s go through the code line-by-line.

```
pub resource interface Receiver
```

- The first line declares a new resource interface called `Provider`.

```
pub fun withdraw(amount: UFix64): @Vault
```

- The second line declares a function called `withdraw` that takes an argument of type `UFix64` and returns a reference to a `Vault`.
- The `amount` parameter represents the amount of tokens to withdraw, and the function returns a new `Vault` resource that holds the withdrawn tokens.

```
post
```

- The `post` block in the `withdraw()` function is used to specify a condition that must hold true after the function is executed.
- In this case, the condition specified in the `post` block is that the balance of the returned `Vault` instance must be equal to the amount that was requested to be withdrawn.

```
result.balance == amount:
```

- The `result` refers to the return value of the `withdraw()` function, which is an instance of the `Vault` resource.

```
"Withdrawal amount must be the same as the balance of the withdrawn Vault"
```

- If the condition specified in the `post` block is not met after the function is executed, an error will be raised with the message `"Withdrawal amount must be the same as the balance of the withdrawn Vault"`.

### `Provider` code block summary

The `Provider` interface is super cool. It gives you this awesome function called `withdraw`, which lets you take out a specific amount of tokens from a `Vault`. It's like having the power to make your tokens rain!

But here's the exciting part: the `withdraw` function doesn't just let you take out tokens randomly. It's smart! It checks if the amount you're withdrawing matches the balance in the `Vault`. If everything matches up, you're good to go. But if something doesn't add up, no worries! It's got your back and shows you an error message. It's like having a built-in security guard for your tokens!

So, with the `Provider` interface, you can confidently withdraw tokens from your Vault and ensure everything is in check. It's all about keeping things exciting, secure, and error-free! Let's make those tokens dance to your tune!

## Implementing the `Receiver` Interface

Let’s look at the implementation of `Receiver` interface.

```
pub resource interface Receiver {

    pub fun deposit(from: @Vault)

    pub fun getSupportedVaultTypes(): {Type: Bool} {
        if self.getType().isSubtype(of: Type<@FungibleToken.Vault>()) {
            return {self.getType(): true}
        } else {
            return {}
        }
    }
}
```

Let’s go through the `resource interface Receiver` code.

```
pub fun deposit(from: @Vault)
```

- This line declares a public function called `deposit` that takes in a parameter called `from`, which is of type `@Vault`.
- This function is used to deposit a `Vault` resource into an account.
- `from` is the `Vault` resource that contains the funds that will be deposited.

```
pub fun getSupportedVaultTypes(): {Type: Bool}
```

- This line declares a public function called `getSupportedVaultTypes`, which returns a dictionary of `Type: Bool` pairs.
- This function is used to check if a particular account supports a certain type of `Vault`.

```
if self.getType().isSubtype(of: Type<@FungibleToken.Vault>()):
```

- This line checks if the account's type is a subtype of the `Vault` type defined in the `FungibleToken` contract.
- It is implemented to make sure that run-time type would only get returned when the parent resource conforms with `FungibleToken.Vault`.

```
return {self.getType(): true}
```

- If the account's type is a subtype of the `Vault` type, this line returns a dictionary with the account's type as the key and **`true`** as the value.
- This indicates that the account supports the `Vault` type.

```
else { return {} }
```

- If the account's type is not a subtype of the `Vault` type, this line returns an empty dictionary, indicating that the account does not support the **`Vault`** type.

### `Receiver` code block summary

The `getSupportedVaultTypes` function is pretty rad. It gives you a map that shows which `Vault` types your account supports. It's like having a treasure map to unlock the possibilities!

Here's the exciting part: If your account supports the `FungibleToken` `Vault` type, the map will have a special key called `Type<@FungibleToken.Vault>`. And guess what? The value will be set to true, like a thumbs-up for supporting `FungibleToken` `Vault`!

But, if your account doesn't support the `FungibleToken` `Vault` type, don't worry! The map will be empty. It's like a blank canvas, ready for you to explore other possibilities!

So, with the `getSupportedVaultTypes` function, you can discover which `Vault` types your account supports and dive into the exciting world of tokens. It's all about finding your unique path and unlocking amazing opportunities! 💪

## Implementing the `Balance` interface

Let’s look at the implementation of `Balance` interface.

```
pub resource interface Balance {

    pub var balance: UFix64

    init(balance: UFix64) {
        post {
            self.balance == balance:
                "Balance must be initialized to the initial balance"
        }
    }

    pub fun getViews(): [Type] {
        return []
    }

    pub fun resolveView(_ view: Type): AnyStruct? {
        return nil
    }
}
```

Let’s go through the `resource interface Balance` code.

```
pub var balance: UFix64
```

- Thie public variable `balance` of type `UFix64` will hold the current balance of a resource.

```
init(balance: UFix64)
```

- `init(balance: UFix64)` is used to initialize the `balance` variable to a specific value, provided as an argument.

```
post {
    self.balance == balance:
        "Balance must be initialized to the initial balance"
}
```

- This is a post-condition that ensures that the `balance` variable is set to the initial balance passed to the constructor.

```
pub fun getViews(): [Type]
```

- This is a public function that returns an empty array of types. This function is used to declare the views of a resource.

```
pub fun resolveView(_ view: Type): AnyStruct?
```

- This is a public function that takes a `Type` argument and returns `nil`. This function is used to resolve views of a resource.

### `Balance` code block summary

Alright, let's dive into the summary of this exciting code! The code introduces the `Balance` interface, which is all about managing and tracking balances for resources. It's like having a personal balance manager for your digital goodies!

Here's the scoop: The interface has a balance variable that keeps track of the resource's balance. It's like having your own virtual piggy bank!

But wait, there's more! The code also includes an initializer function that sets the initial balance when the resource is created. It ensures that the initial balance matches the provided value. It's like having a rock-solid foundation for your digital riches!

The Balance interface doesn't stop there. It offers additional functions, like `getViews` and `resolveView`. These functions allow you to explore different views of your balance and resolve any queries or requests related to those views. It's like having a dynamic way to manage and interact with your balance!

So, with the Balance interface, you can easily initialize and manage balances for your resources, explore different views, and resolve any queries that come your way. It's all about staying on top of your digital wealth and making it work for you! Let's unleash the power of balance management!

## Wrap up

You're doing amazing! 🙌 You've covered field requirements and resource interfaces, but guess what? The excitement continues!

Get ready to dive in and bring your `FungibleToken` contract interface to life by implementing resources and functions. It's like connecting the dots to make the magic happen with your token!

So buckle up for this thrilling next step as you unlock a new level of understanding and unleash your skills. Let's make incredible things happen together!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/3.%20Create%20Your%20First%20Flow%20Token%20-%20I.md

Create Your First Flow Token - I

# Create Your First Flow Token - II

Hey there, rockstar learner! In the last lesson, you covered the basics of the awesome `FungibleToken` interface. Now, get ready to level up and explore even more!

In this thrilling lesson, you're diving deeper into the world of `FungibleToken`. Hold on tight as you learn how to implement the Vault resource. It's like building your very own treasure chest to store those precious tokens!

## Implementing the `Vault` resource

Let’s look at the implementation of `Vault` resource.

```
// Declaring a new resource called Vault which
// implements the interfaces Provider, Receiver, and Balance.
pub resource Vault: Provider, Receiver, Balance {

		// The variable used to keep track of the amount of funds held in the Vault.
    pub var balance: UFix64

		// This is the constructor for the Vault resource
    init(balance: UFix64)

    pub fun withdraw(amount: UFix64): @Vault {
        pre {
            self.balance >= amount:
                "Amount withdrawn must be less than or equal than the balance of the Vault"
        }
        post {
            self.balance == before(self.balance) - amount:
                "New Vault balance must be the difference of the previous balance and the withdrawn Vault"
        }
    }

    pub fun deposit(from: @Vault) {
        pre {
            from.isInstance(self.getType()):
                "Cannot deposit an incompatible token type"
        }
        post {
            self.balance == before(self.balance) + before(from.balance):
                "New Vault balance must be the sum of the previous balance and the deposited Vault"
        }
    }
}
```

Let’s go through `pub resource Vault: Provider, Receiver, Balance` the code.

```
pub fun withdraw(amount: UFix64): @Vault
```

- This function allows a user to withdraw funds from the Vault.
- The function takes an amount parameter and returns a reference to the Vault resource.

```
pre {
    self.balance >= amount:
        "Amount withdrawn must be less than or equal than the balance of the Vault"
}
```

- This is a precondition which checks that the balance of the `Vault` is greater than or equal to the amount being withdrawn.
- The precondition checks that the current balance of the `Vault` is greater than or equal to the amount being withdrawn. If the precondition is false, an error message will be thrown.

```
post {
    self.balance == before(self.balance) - amount:
        "New Vault balance must be the difference of the previous balance and the withdrawn Vault"
}
```

- This is a post-condition which checks that the balance of the `Vault` after the withdrawal is equal to the balance before the withdrawal minus the amount withdrawn.
- The postcondition checks that the new balance of the `Vault` is equal to the previous balance minus the amount withdrawn.
- If the postcondition is false, an error message will be thrown.

```
pub fun deposit(from: @Vault)
```

- This function allows a user to deposit funds into the `Vault`.
- The function takes a reference to another Vault resource as a parameter.
- The function does not return anything.

```
pre {
    from.isInstance(self.getType()):
        "Cannot deposit an incompatible token type"
}
```

- This line specifies a precondition for the `deposit` function using the `pre` keyword.
- This is a precondition which checks that the type of the `Vault` being deposited matches the type of the current `Vault`.
- If the precondition is false, an error message will be thrown.

```
post {
    self.balance == before(self.balance) + before(from.balance):
        "New Vault balance must be the sum of the previous balance and the deposited Vault"
}
```

- This line specifies a postcondition for the `deposit` function using the `post` keyword.
- This is a postcondition which checks that the balance of the `Vault` after the deposit is equal to the balance before the deposit plus the balance of the deposited `Vault`.
- If the postcondition is false, an error message will be thrown.

### `Vault` code block summary

This code introduces a resource called Vault that is super powerful! It implements three cool interfaces: Provider, Receiver, and Balance. It's like a Swiss Army knife of functionalities!

When a Vault resource is created, it's initialized with a specific balance amount. It's like setting the starting point for your digital wealth! 💰

Now, here's where it gets interesting: the Vault resource offers two functions: withdraw and deposit. The withdraw function lets a user take out a specific amount from the vault, but only if the vault's balance is equal to or greater than the amount being withdrawn. It's like having a security check to ensure you're not going overboard!

On the other hand, the deposit function allows a user to add another compatible Vault resource into the current vault, but only if it's the same type. It's like merging two powerful vaults into one!

After every deposit or withdrawal, the new balance of the vault is checked to make sure it matches the expected balance. It's like having a double-check to ensure everything is in order!

So, with this code, you have the ability to manage your vault, withdraw funds securely, deposit compatible resources, and maintain the perfect balance. It's all about taking control of your digital riches and making sure everything is working smoothly!

## Implementing Empty Vault

Let’s look at the implementation of Empty Vault.

```
// This is a public function named createEmptyVault()
// that returns a reference to a newly created Vault instance.
pub fun createEmptyVault(): @Vault {
    post {
        result.balance == 0.0: "The newly created Vault must have zero balance"
    }
}
```

Let’s go through `createEmptyVault(): @Vault` the code.

```
post {
    result.balance == 0.0: "The newly created Vault must have zero balance"
}
```

- This is a postcondition that verifies that the `Vault` instance created by `createEmptyVault()` has a zero balance.
- `result.balance == 0.0` is the condition being checked in the postcondition.
- It verifies that the `balance` property of the `Vault` instance returned by `createEmptyVault()` is equal to zero.
- `"The newly created Vault must have zero balance"` is an error message that will be displayed if the postcondition fails. It explains what went wrong and how to fix it.

## Complete Fungible Token code

Let’s look at the complete code of the Flow Fungible Token.

```
// A Fungible Token contract interface definition
pub contract interface FungibleToken {

		// The total supply of the fungible token
    pub var totalSupply: UFix64

		// Event triggered when the tokens are initialized
    pub event TokensInitialized(initialSupply: UFix64)

		// Event triggered when tokens are withdrawn from a vault
    pub event TokensWithdrawn(amount: UFix64, from: Address?)

		// Event triggered when tokens are deposited into a vault
    pub event TokensDeposited(amount: UFix64, to: Address?)

    // Resource interface for withdrawing tokens from a vault
    pub resource interface Provider {

        // Withdraw tokens from a vault and return a reference to the withdrawn vault
        pub fun withdraw(amount: UFix64): @Vault {
            post {
                result.balance == amount:
                    "Withdrawal amount must be the same as the balance of the withdrawn Vault"
            }
        }
    }

    // Resource interface for depositing tokens into a vault
    pub resource interface Receiver {

        // Deposit tokens into a vault
        pub fun deposit(from: @Vault)

        // Get the types of vaults supported by this contract
        pub fun getSupportedVaultTypes(): {Type: Bool} {
            if self.getType().isSubtype(of: Type<@FungibleToken.Vault>()) {
                return {self.getType(): true}
            } else {
                return {}
            }
        }
    }

    // Resource interface for keeping track of the balance of a vault
    pub resource interface Balance {

				// The current balance of the vault
        pub var balance: UFix64

        // Initialize the balance of a new vault
        init(balance: UFix64) {
            post {
                self.balance == balance:
                    "Balance must be initialized to the initial balance"
            }
        }

        // Get the views available for this resource
        pub fun getViews(): [Type] {
            return []
        }

        // Resolve a view of this resource
        pub fun resolveView(_ view: Type): AnyStruct? {
            return nil
        }
    }

    // Resource definition for a fungible token vault
    pub resource Vault: Provider, Receiver, Balance {

				// The current balance of the vault
        pub var balance: UFix64

        // Initialize the balance of a new vault
        init(balance: UFix64)

        // Withdraw tokens from the vault and return a reference to the withdrawn vault
        pub fun withdraw(amount: UFix64): @Vault {
            pre {
                self.balance >= amount:
                    "Amount withdrawn must be less than or equal than the balance of the Vault"
            }
            post {
                self.balance == before(self.balance) - amount:
                    "New Vault balance must be the difference of the previous balance and the withdrawn Vault"
            }
        }

        // Deposit tokens into the vault
        pub fun deposit(from: @Vault) {
            pre {
                from.isInstance(self.getType()):
                    "Cannot deposit an incompatible token type"
            }
            post {
                self.balance == before(self.balance) + before(from.balance):
                    "New Vault balance must be the sum of the previous balance and the deposited Vault"
            }
        }
    }

    // Create a new empty vault
    pub fun createEmptyVault(): @Vault {
        post {
            result.balance == 0.0: "The newly created Vault must have zero balance"
        }
    }
}
```

## Wrap up

Woohoo! 🎉 Congrats on creating your very own Fungible Token on Flow! You're a superstar in the making! You've mastered all the fundamental concepts to bring your token dreams to life.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/3.%20Let%E2%80%99s%20Start%20The%20Fun%20Part/4.%20Create%20Your%20First%20Flow%20Token%20-%20II.md

Create Your First Flow Token - II

Let’s Start The Fun Part

Let's wrap up the course and go through what you have learned so far.

# Let’s Wrap It Up

Alright, let's wrap it up and celebrate your incredible journey! 🎉 It's time to take a moment and reflect on everything you've learned in this course. Get ready for a quick recap that will leave you feeling accomplished and ready to conquer the world!

So, take a deep breath and pat yourself on the back. You've come a long way, my friend! It's time to embrace your newfound knowledge and continue exploring the amazing possibilities that lie ahead. Remember, this is just the beginning of an epic journey!

So keep that fire burning, stay curious, and keep learning. The world is your oyster, and you're equipped with the tools to make a real impact. Go out there and shine brightly!

## Understanding of Flow Blockchain

You now have a solid foundation and a clear understanding of what Flow is all about. You've learned how it works, diving into its inner workings and understanding the genius behind its design. It's like peering into the mind of a brilliant inventor!

But here's the exciting part: you now know why Flow is so important in the blockchain space. It's like having the key to unlock a whole new world of possibilities!

## Familiarity with Cadence

You've aced the basics of Cadence! From its syntax to data types, visibility specifiers, and writing simple smart contracts, you've become a coding superstar! Now, it's time to unleash your creativity and build incredible things with Cadence's limitless potential.

Get ready to conquer the digital realm with your newfound skills and watch as your coding journey reaches new heights! Keep pushing boundaries, my friend, and let your Cadence expertise shine bright!

## Writing and Deploying a Smart Contract

You've now unlocked the power to write and deploy your very own simple smart contracts on the incredible Flow Blockchain, all thanks to the Flow Playground! It's like having a virtual playground where you can bring your ideas to life and unleash them into the digital world!

## A Solid Foundation in Smart Contract Development

With a solid grasp of the Flow Blockchain and Cadence basics, you're now equipped to dive deeper into the world of smart contract development on Flow. It's like stepping into a universe of innovation and opportunity, where your creativity knows no bounds!

## Fungible Token Standard

Throughout your journey, you've delved into the fascinating world of the Fungible Token Standard, exploring it with immersive coding examples. Starting with a solid foundation in the diverse standards of the Flow ecosystem, you then took the plunge and dived deep into the intricacies of the Fungible Token Standard. It's like unlocking the secret recipe for creating digital currencies!

## Writing and Deploying a Fungible Token

You've just acquired the incredible power to write and deploy your very own Fungible Token on the Flow Blockchain, all thanks to the mighty Flow Playground!

## 🎊 Congratulations

You did it! 💪 You've conquered the course and now hold the keys to unlock the thrilling world of blockchain and smart contract development on the Flow Blockchain! Get ready to embark on an exhilarating journey where you can turn your wildest ideas into reality. The possibilities are endless, and the future is yours to shape! So, let your creativity soar high and dive into the exciting realm of blockchain development on Flow. It's time to make your mark and be part of the revolution!

WAGMI! Peace out! ✌🏻🔮


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Write%20Your%20First%20Smart%20Contract%20on%20Flow%20Blockchain/4.%20Let%E2%80%99s%20Wrap%20It%20Up/Let%E2%80%99s%20Wrap%20It%20Up.md

Write Your First Smart Contract on Flow Blockchain

Project Curriculum

Let’s Get Started

Unleash the Power of Cadence Programming Language

Let’s Start The 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