Sui is a high-performance modern blockchain, which leverages the Move on Sui to deploy secure and efficient smart contracts and dApps. This course is specifically designed to set the base for developers who want to explore the vastness of the Move on Sui programming language, learn about its working, syntax, and features and eventually write the calculator code from scratch to put their learning into practice.

This self-paced course teaches you all about the practical applications of Move on Sui and explore its limitless possibilities. Enroll today to get started.

Build on Move on Sui and Explore its Applications

Start the course by getting to know Move on Sui—understand its purpose, discover its uniqueness, and explore the features it brings to the table.

# What Are We Building Today

Gm everyone ☀️, today we are very excited to bring the second course of our detailed series about Sui blockchain for developers on Metaschool. Let’s start the second course by congratulating you for completing the first course on Sui. Woohoo!

In the first course, we took you through the basics of Sui blockchain and how it works. In this course, we will dive deeper and learn Move on Sui language which is the native programming language of Sui. In short, in this course, you are also going to build on Sui using Move on Sui and we can’t wait for you to start.

## Course Overview

We will:

1. Set up our development environment
2. Run our first Sui contract
3. Understand Move on Sui’s Package Architecture
4. Learn the basics of Move on Sui language
5. Test your knowledge via multiple challenges

## Who exactly should take this course?

This course is for beginner web3 developers who wish to learn about Sui blockchain and have completed our first introduction course on Sui. You should have basic programming knowledge as it will help you have a quick start to this course.

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

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

1. Learn Move on Sui on Sui basics
2. Build dApps on Sui
3. Explore opportunities within the Sui ecosystem via SuixMetaschool Discord House
4. Earn up to 1000 XPs
5. Claim your NFT on course completion

## Proof of completion

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

![img](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c1/What%20Are%20We%20Learning%20Today%3F/image.gif?raw=true)

Now before we move forward, let’s set some house rules first.
1. Kindly do your quick assignments properly.
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. We are a free open-source platform and if you follow us on [X](https://bit.ly/move-on-sui-twitter) and [LinkedIn](https://bit.ly/move-on-sui-linkedin), it would be a great support.  🫣
4. Stay happy and positive!



Alright guys, no need to wait any longer. But before even starting to learn about Move on Sui, let’s see what exactly is Move on Sui and the perks it brings to the table in the next section. See you there!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/1.%20Getting%20Started/1.%20What%20Are%20We%20Building%20Today.md

What Are We Building Today

# Why Move on Sui was Created

Let’s start by understanding Sui, the difference between Move on Sui and Move, and why Move on Sui is a game changer in the blockchain.

## Let’s recall, Sui Chain

Sui is a decentralized layer 1 blockchain which has changed the way we define asset ownership in blockchain and how the transactions are processed.

![sui-icon.jpeg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Why%20Move%20on%20Sui%20was%20Created/sui-icon.jpeg?raw=true)

Sui introduced composable objects with Move on Sui. These objects can be single owned and shared owned. For single-owner simple transactions like transferring tokens or NFT, Sui forgoes consensus. These transactions from different users are independent of each other and hence Sui implements these transactions in a parallel manner called Parallel Transaction. Meaning, that each transaction can be processed simultaneously at a given time. This increases the scalability of Sui exponentially. Well, we will talk about this later in the course.

For shared owner objects, Sui implements a consensus mechanism called Delegated Proof of Stake. To explain in simple terms, this means that when a transaction is submitted, the validators vote on whether to approve the transaction or not.

## What exactly is Move?

You must have gone through Move on Sui in the “Introduction to Sui Chain” course. But let’s just take a step back.

Before Move on Sui was built, the Move programming language existed, which we usually refer to as Core Move. Core Move is an open-source programming language that is mainly used to build and manipulate smart contracts. The Move enables common libraries, tooling, and developer communities across different blockchains. Move is also adaptable, meaning we can do multiple enhancements to it to perform different operations. And that is exactly what Move on Sui is doing. It uses the core Move and enhances it to make a Move that is compatible with Sui.

## Move on Sui

Move on Sui has some major differences from core Move or Move on other blockchains. Move on Sui benefits from the Move flexibility, and security and enhances it to the extent that it increases the throughput, reduces the delay, and makes the Move programming language more approachable and best to work with. Let’s go through some of the unique features Move on Sui has.

## Key differences in Move on Sui

Following are the key differences in Move on Sui:

1. Sui has its object-centric storage
2. Addresses in Sui represent object IDs
3. Each object in Sui has unique IDs globally
4. Sui has a module initializer (init)
5. Sui has entry points that take objects by reference as input

Let's briefly discuss these differences.

### Object-centric storage

The Sui chain has its own Sui storage instead of global storage. The global storage in core Move causes scalability issues, which the Sui chain solves by keeping the objects and modules owned by addresses on the Sui chain. All of the transactions made in the Sui chain are represented via unique identifiers, to allow the chain to run the transactions in parallel.

### Addresses in Sui represent object IDs

Well, in Move on Sui, Sui uses a 32-byte address identifier to represent the account addresses. Each transaction is signed by the account address, the sender, to access all of the information of the transaction. The account address, in Move on Sui, is stored in id: UID the compulsory field in objects.

### Object with key abilities, globally unique IDs

In Sui, using the key ability is crucial to turn a simple struct into a Sui object. The object with key ability must have an id: UID field, which stores the object’s unique address.

### Module initializer

Module initializer works like a constructor in Move on Sui. As we discussed, if you publish modules in Sui storage, the initializer helps initialize the initial values of the object’s fields. The initializer is executed at runtime, which means when you publish the module the initializer gets executed only once.

### Entry points take objects by reference as input

In Move on Sui, you can pass the objects as inputs to the public functions, which are callable by Sui transactions. There are multiple ways to do it. You can either pass them by reference, by mutable reference, or by value. Here, the objects passed by value can get deleted or can be transferred to another owner whereas you can change the data of the objects passed by mutable reference without changing the ownership or making any new instance.

In Move on Sui, you can also call entry functions, even if they are private as long as other non-entry functions have not used their inputs.

**Don’t worry!** We will discuss all of the above mentioned topics in detail in upcoming lessons.

## That’s a wrap

The Move on Sui is different and unique in many aspects. It offers many unique features that help us scale our applications. So, working with Move on Sui will help you deploy scalable unique smart contracts. I know it seems a lot! But I’ve got you and I will discuss all of the new concepts in upcoming lessons in detail. For now, let’s move forward and learn how you can set up the dev environment to run the Move on Sui programs and learn to deploy your first program on Sui.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/1.%20Getting%20Started/2.%20Why%20Move%20on%20Sui%20was%20Created.md

Why Move on Sui was Created

Kris

Ajay

Getting Started

Prepare your development environment, launch your initial smart contract on Sui, and configure your Sui wallet.

# Set Up the Development Environment

Welcome back! I hope you enjoyed learning about the Sui and Move programming language. In this lesson, I will guide you through setting up the development environment to run Move on Sui programs on your system. Before we dive into that, it's crucial to ensure that you have installed all the necessary prerequisites on your system. **Don't worry!** I will provide you with the installation instructions for your specific system. So, feel free to scroll through the lesson to find the relevant installation guide.

## Prerequisite installments for MacOS

Let's go through the necessary steps to install Move on Sui on your MacOS. Open your terminal and run the following commands.

1. Install `brew` using the following command:

```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

1. Install `cURL` using the following command:

```
brew install curl
```

1. Install `CMake` using the following code:

```
brew install cmake
```

1. Install Git:

```
brew install git
```

## Prerequisite installments for Linux

Now, let's go through the prerequisite installations you need to do to install Move on Sui on your Linux system.

1. Update `apt-get` using the following command:

```
sudo apt-get update
```

1. Install `cURL` using the following command:

```
sudo apt install curl
```

1. Install Git CLI:

```
sudo apt-get install git-all
```

1. Install `cMake` using the following command:

```
sudo apt-get install cmake
```

1. Install `GCC`:

```
sudo apt-get install gcc
```

1. Install `libssl-dev`:

```
sudo apt-get install libssl-dev
```

1. Install `pkg-config`. This command is optional. Install if you have OpenSSL in your system.

```
sudo apt-get install pkg-config
```

1. Install `libclang-dev`:

```
sudo apt-get install libclang-dev
```

1. Install `libpq-dev`:

```
sudo apt-get install libpq-dev
```

1. Install `build-essential`:

```
sudo apt-get install build-essential
```

## Prerequisite installments for Windows

Let’s go through the prerequisite installments you need to install Move on Sui on your Windows.

1. Windows 11 already has installed the Microsoft version of `cURL`.
2. Download and install Git CLI using this link: [https://git-scm.com/download/](https://git-scm.com/download/)
3. Download and install `cMake` from here: [https://cmake.org/download/](https://cmake.org/download/)
4. Download and install [Protocol Buffers](https://github.com/protocolbuffers/protobuf/releases). Do add them to your Windows `PATH` environment variable.
5. Download and install C++ build tools: [https://visualstudio.microsoft.com/downloads/](https://visualstudio.microsoft.com/downloads/)

**Note**: The `sui console` command does not work in PowerShell.

## Install Cargo and Rust

Now that you have done all the prerequisite installations in your system, whether it is MacOS, Linux, or Windows, you need to install Cargo and Rust. Run the following command to do that.

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

You can also visit the [Rust official page](https://www.rust-lang.org/tools/install) for other ways of installing Rust.

## Set up Move on Sui

Now that everything is done, let’s finally install Sui. Run the following command to install the Sui binaries from `devnet`.

```
cargo install --locked --git https://github.com/MystenLabs/sui.git --branch devnet sui
```

Check your Sui installation version.

```
sui --version
```

**Note:** If you face errors while installing Sui please make sure that all of the prerequisites are updated.

## That’s a wrap

After successfully setting up your development environment, let's move on to running and deploying the “Hello World” program. This will give you a glimpse of how to deploy your smart contract on the Sui blockchain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/2.%20Deploying%20Your%20First%20Hello%20World%20Contract%20on%20Sui/1.%20Set%20Up%20the%20Development%20Environment.md

Set Up the Development Environment

# Deploy Your First Sui Contract

Great work on setting up your development environment for Move on Sui. In this lesson, we will learn to run and deploy a “Hello World” smart contract on the Sui blockchain and explore it in the Explorer.

## Deploy your first Sui contract

Open your favorite terminal because we will be running a few commands to achieve our goal.

The first step is to initialize a workspace environment. This will contain the basic files for running any Move file. You can create the workspace using the following command; I have named mine `hello_world`:

```
sui move new hello_world
```

The command will generate a folder named `hello_world` and it will contain a file `Move.toml` and a folder `sources`:

![deploy-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-1.png?raw=true)

- P.S.: I am using Visual Studio IDE as it visualizes the structure of my workspace better.

Navigate to the `sources/` directory. Create a new Move file. I am naming it `Hello.move`.

![deploy-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-2.png?raw=true)

Paste the following code in the `Hello.move` you just created:

```
// Copyright (c) 2022, Sui Foundation
// SPDX-License-Identifier: Apache-2.0

/// A basic Hello World example for Sui Move, part of the Sui Move intro course:
/// https://github.com/sui-foundation/sui-move-intro-course
/// 
module hello_world::hello_world {

    use std::string;
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    /// An object that contains an arbitrary string
    struct HelloWorldObject has key, store {
        id: UID,
        /// A string contained in the object
        text: string::String
    }

    public entry fun mint(ctx: &mut TxContext) {
        let object = HelloWorldObject {
            id: object::new(ctx),
            text: string::utf8(b"Hello World!")
        };
        transfer::public_transfer(object, tx_context::sender(ctx));
    }

}
```

- **Note:** This lesson just focuses on running our “Hello World” program on Sui. We will talk about the file details and explanations in the upcoming lessons. So don’t worry–we have got it for you!

## Build and publish on Sui

Now let’s build our Move file using the following command:

```
sui move build
```

This will generate an output like the following:

![deploy-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-3.png?raw=true)

After running the command, your project directory will include a `build` folder and a `Move.lock` file.

![deploy-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-4.png?raw=true)

### Create your Sui account

Now let’s run the following command to create your Sui account:

```
sui client new-address ed25519
```

It will generate the output something like this:

![deploy-5.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-5.png?raw=true)

- **Important**: Save the recovery phrase, we will need it in the next lesson to set up our wallet.

Replace `[YOUR_ADDRESS]` in the command below with your address and run it.

```
sui client switch --address [YOUR_ADDRESS]
```

You can also view which is the current active address using the `sui client active-address` command:

![deploy-6.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-6.png?raw=true)

Lastly, head over to the [Sui Devnet faucet discord channel](https://discord.com/channels/916379725201563759/971488439931392130) and paste “!faucet [YOUR_ADDRESS]” to receive 10 SUI tokens.

### Set up the dev env

To deploy on Sui Devnet, please execute the following commands.

```
sui client new-env --alias devnet --rpc https://fullnode.devnet.sui.io:443
sui client switch --env devnet
```

### Publish the contract

First, copy the absolute path of your `Hello.move` file:

![deploy-7.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-7.png?raw=true)

Replace `[YOUR_PATH]` with the absolute path of your file and run the following command:

```
sui client publish --gas-budget 10000000 [YOUR_PATH]
```

We will have a long output but scroll to the start of the output and copy the Transaction Digest:

![deploy-8.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-8.png?raw=true)

Head over to [https://suiexplorer.com/?network=devnet](https://suiexplorer.com/?network=devnet). Paste the Transaction Digest in the search bar to find your transaction on the Sui Explorer:

![deploy-9.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Deploy%20Your%20First%20Sui%20Contract/deploy-9.png?raw=true)

Whoo! You did great! We have deployed our first “Hello World” program on Sui 🎉

## That’s a wrap

In conclusion, this lesson introduced the process of running smart contracts on Sui. We learned how to create a Move workspace, build and publish Move files, create a Sui account, and deploy a contract on the Sui devnet. Congratulations on completing this lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/2.%20Deploying%20Your%20First%20Hello%20World%20Contract%20on%20Sui/2.%20Deploy%20Your%20First%20Sui%20Contract.md

Deploy Your First Sui Contract

# Set Up Sui Wallet

Welcome back! So you completed learning about Sui and Move programming language. Well in this lesson, you're going to learn how to set up your Sui wallet. Ready for another round of exhilarating learning? Let's dive right in!

## Setup Sui wallet

Let’s install the Sui wallet so you can deploy your contract.

You can add it easily using the browser extension. For Chrome, go to [this](https://chrome.google.com/webstore/detail/sui-wallet/opcgpfmipidbgpenhmajoajpbobppdil) link and then add it to Chrome.

![sui-1-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/sui-1-1.png?raw=true)

Once you add the Sui wallet extension to Chrome, you will be redirected to the new page. Sign up with your Gmail. Then you can see the “Add” option, click on it.

![Frame 3560370 (2).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Frame_3560370_(2).jpg?raw=true)

 After that, you will see an option of “Import passphrase”. Click on it.

![Frame 3560370 (3).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Frame_3560370_(3).jpg?raw=true)

Remember I asked you to save your recovery phrase of the wallet you created in the last lesson. It is time to use it here now. Paste your recovery phase and click on “Add Account”.

![Frame 3560370 (4).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Frame_3560370_(4).jpg?raw=true)

Set your password and accept the terms and conditions. Click on “Create Wallet”.

![Frame 3560370 (6).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Frame_3560370_(6).jpg?raw=true)

After creating the wallet, you can see your account.

![Frame 3560370 (5).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Frame_3560370_(5).jpg?raw=true)

Currently, this is set to Mainnet, you can hover over the settings icon in the top right corner. Go to Network and change to the desired network. We are changing to the Devnet network as we deployed our contract to the Devnet network.

![Screen Recording 2023-11-03 at 11.01.49 AM.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Screen_Recording_2023-11-03_at_11.01.49_AM.gif?raw=true)

## Get some fake tokens

You can request the SUI tokens just by clicking on the “Request Devnet SUI Tokens” button. 

![Frame 3560370 (7).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Set%20Up%20Sui%20Wallet/Frame_3560370_(7).jpg?raw=true)

- **Note**: If you need SUI tokens for other networks like Testnet, just change the network and request tokens.

## Wrap up

In this lesson, you learned about setting up a Sui wallet and how to get a few coins on your network. Next, we will dive into understanding the architecture of the Move on Sui package that we created in this section. We will also explore what the basic smart contract structure looks like in Move on Sui in the next section. So keep your momentum going.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/2.%20Deploying%20Your%20First%20Hello%20World%20Contract%20on%20Sui/3.%20Set%20Up%20Sui%20Wallet.md

Set Up Sui Wallet

Inioluwa Oladipupo

TaeKwon

Gabriel Silva

Deploying Your First Hello World Contract on Sui

Grasp the Move Sui package and its default files. Acquire the fundamentals of the smart contract structure in Move on Sui.

# Understand Move.toml and Move.lock File

Now that you know how to create the Move package using the Move on Sui. In this lesson, we will explore the important components of the Move package in detail. We will explore how `Move.toml` and `Move.lock` files work and what their use cases are.

## Move.toml file

When you create a Move package using the `sui move new` command it creates a `Move.toml` file with it. By default, it holds a couple of things, but with time as you grow, you’ll find out that you need to change things in the file and make it according to your needs. So, eventually, we need to understand this file in detail to work with it easily in the future.

You might have noticed that the `Move.toml` file has three main components. Let’s explore them.

1. `[package]`: The `[package]` section contains the name and the version of your Move package. It represents the metadata of your package.
2. `[dependencies]`: The `[dependencies]` represent all of the packages our Move package depends on. By default, the only package that is mentioned here is the Sui framework, but as you progress, you can add more packages here.
3. `[addresses]`: This represents the list of named addresses. This field helps us give aliases to addresses we want to use in the smart contract code.

Now, let’s discuss the components in detail with examples.

### `[package]` section

The `[package]` section has the following three important fields.

1. `name`: The `name` field helps identify the name of your Move package name that you create at the time you run `sui move new`, for example, `sui move new hello_world`.
2. `version`: The `version` helps identify the version of your package. By default, the Sui compiler gives your package the first version, for example, `0.0.1`, at the time of package creation.
3. `published-at`: This field is not created by the Move compiler by default. This field helps identify the address of our package. For example, the Sui framework was published at `0x2` address so its published-at will be `"0x2"`. We include this field after publishing our package and help other packages access our package using the `published-at` address.

Now, Let’s look at how the `[package]` section looks in the `Move.toml` file by default.

```
[package]
name = "hello_world"
version = "0.0.1"
```

Here’s what the `[package]` section looks like after adding the `published-at` field. Remember that this is just an example, addresses can vary.

```
[package]
name = "hello_world"
version = "0.0.1"
published-at = "0x0"
```

### `[dependencies]` section

By default, the Sui compiler adds one package in the `[dependencies]` section. It adds the Sui Framework using the GitHub link. Here’s what it looks like by default:

```
[dependencies]
Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "framework/testnet" }
```

You can also import any package from the local path. To do so, you add the package like this.

```
Sui = { local = "../crates/sui-framework" }
```

### `[addresses]` section

By default, the Sui compiler adds two addresses in the `[addresses]` section: one is the address of your package and the other is the address to the Sui network. Here’s what it looks like.

```
[addresses]
hello_world = "0x0"
sui =  "0x2"
```

Here, aliases, for example, `sui`, help us import packages from `sui` in our smart contract with ease like this:

```
use sui::transfer
```

Without an alias, we would have needed to write the address which can create confusion for us.

## `Move.lock` file

When you build your Move package using the `sui move build` command, it creates the `Move.lock` file at the root directory of your package. The `Move.lock` file contains the information about your package and the dependencies it needs to import. This helps verify your source code and the code it is importing.
As the `Move.toml` file is editable, the `Move.lock` file is not editable. `Move.lock` helps the compiler identify the essential things needed to run the Move package which is why we cannot change either move the `Move.lock` file to any other place. Here’s how our `Move.lock` of `hello_world` module looks like.

```
# @generated by Move, please check in and do not edit manually.

[move]
version = 0
manifest_digest = "1EA2B7F6C986E247256A7F281C4A866CE325DE9724C9D8BCBE2B0BA4CB7E18C5"
deps_digest = "F8BBB0CCB2491CA29A3DF03D6F92277A4F3574266507ACD77214D37ECA3F3082"

dependencies = [
  { name = "Sui" },
]

[[move.package]]
name = "MoveStdlib"
source = { git = "https://github.com/MystenLabs/sui.git", rev = "framework/testnet", subdir = "crates/sui-framework/packages/move-stdlib" }

[[move.package]]
name = "Sui"
source = { git = "https://github.com/MystenLabs/sui.git", rev = "framework/testnet", subdir = "crates/sui-framework/packages/sui-framework" }

dependencies = [
  { name = "MoveStdlib" },
]
```

## That’s a wrap

`Move.toml` and `Move.lock` files play a vital role in the Move package, that’s why it was important to learn how they work and why we even need them. Next, we will explore how even the smart contract is declared in Move on Sui. We will explore the usage of the `module` and `use` keywords in Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/3.%20Move%20on%20Sui%20Package%20Architecture/1.%20Understand%20Move%20toml%20and%20Move%20lock%20File.md

Understand Move.toml and Move.lock File

# Basic Module Structure in Move on Sui - I

Great work on learning how you can set up your Move on Sui package and how important components of the Move on Sui package work. Now, in this lesson, we will explore what the structure of a smart contract looks like in Sui Move. What different components make a complete smart contract in Sui move?

## `module` keyword

In Move on Sui, we declare a smart contract using the `module` keyword, just like we declare a smart contract in Solidity using the `contract` keyword. Following is the complete syntax of declaring the smart contract.

```
module package_name::module_name {
		// module code goes here
}
```

Let’s understand what `package_name` and `module_name` represent here.

- The `package_name` is the name that you give to your package at the time of package creation, for example, in the sui move new hello_world command, the package name is `hello_world`.
- The `module_name` is the name of the module that you are creating in your package. There can be multiple modules in one package that’s why it's important to explicitly mention the module name.

Let’s see how it looked at our “Hello World” example.

```
module hello_world::hello_world {
		// module code goes here
}
```

All of the content of the contract goes inside the `module` in Move on Sui. Even the import statements, unlike Solidity programming language.

## `use` keyword

In Move on Sui, `use` is used to import any module inside of our module. Here’s what the complete structure of `use` looks like.

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

Let’s understand what `<Address/Alias>` and `<ModuleName>` represent here.

- The `<Address/Alias>` represents the address of the module we want to use in our module. To keep things simple, we can also use the alias instead of an address here and mention the alias in our `Move.toml` file, as we discussed in the last lesson.
- The `<ModuleName>` simply represents the module name. For example, if the `sui` package has a `transfer` module that we want to use in our module, then we will do something like this:

```
use sui::transfer
```

### Some important Move on Sui modules

Let’s explore some of the important Move on Sui modules that we use in most of the smart contracts.

- `use std::string;`
    - This import statement helps us use strings in our module.
- `use sui::transfer;`
    - This statement helps us code the functionality of transferring an object from one account address to another.
- `use sui::object;`
    - This line helps import the `object` module from the `sui` framework. This module helps create an object in our module.
- `use sui::tx_context;`
    - This helps import `tx_context` from the `sui` framework. `tx_context` helps us identify the basic information of the transaction, such as the sender’s address, the signer’s address, the epoch number of `tx`, etc.

There are multiple other modules in Move on Sui for different purposes. For now, these are enough to learn.

## That’s a wrap

We discussed the basic two important keywords that helped us create the module in Move. Where `module` keyword plays a part in creating a module in Sui Move and `use` plays a part in importing any module. Next, we will explore more important terms that help create the module in Sui Move.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/3.%20Move%20on%20Sui%20Package%20Architecture/2.%20Basic%20Module%20Structure%20in%20Move%20on%20Sui%20-%20I.md

Basic Module Structure in Move on Sui - I

# Basic Module Structure in Move on Sui - II

Now that you have learned the main two components of the Sui module structure, let’s dive more into what other things make a complete and secure Sui module.

## Sui Move Objects

In this lesson, we'll give you a quick intro to Move on Sui Objects, and we'll explore them more in the upcoming lessons. In Move on Sui, objects carry vital information about the module—things like your account address, the current balance in your wallet, or the amount you want to transfer.

You can create objects using the `struct` keyword, but here's the twist. Unlike other programming languages like Go, where you just use a `struct` to declare one, in Move on Sui, you can't simply use the `struct` keyword to create a Move object. It's a must to pair it with the `key` to make it a Sui Move object. Here’s what the structure looks like. **Don’t worry!** We will discuss what `key` is in detail in upcoming lessons.

```
struct StructName has key {
		// struct contents goes here
}
```

For each `module` and `struct` in Move on Sui–it is important to have an ID that helps identify the account address of the one that created the object. Here’s how you can do that.

```
use sui::object::UID;

struct StructName has key {
    id: UID,
    // other struct contents go here
}
```

**Don’t worry!** We will discuss objects in detail in upcoming lessons after covering the basics. Let’s just focus on a simple `module` structure for now.

## Move on Sui Constructor (Module initializer)

In Move on Sui, constructors are called when a module gets published. It means the constructor is only called once. So, constructor functions help us do something that we only want to do once, for example, defining the security and making sure that only the creator of the module can change or own the objects. The constructor also helps in initializing the objects and making sure they hold the right account address. It has the following properties.

1. The function name must be `init`.
2. It must have either of the following types of last arguments.
    1. `&TxContext`
    2. `&mut TxContext`
3. It must not have any return value.
4. It can have optional parameters, for example, any object, or a variable of any type.

Let’s look at its basic coding structure.

```
fun init(optional_parameter: anyDataType, ctx: &mut TxContext) {	
    // init code goes here
}
```

Let’s look at an example code to understand `init` better.

```
module examples::init {
    use sui::transfer;
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};

    // Defining the ExampleObject
    struct ExampleObject has key {
        id: UID
    }

    // init will be only called once at the time of publishing the module
    // Here, we are restricting the object so that only the owner can own 
    // the object
    fun init(ctx: &mut TxContext) {	
        transfer::transfer(ExampleObject {
            id: object::new(ctx),
        }, tx_context::sender(ctx))
    }
}
```

Here, `init` takes one argument (`ctx: &mut TxContext`) and uses `transfer::transfer()` to transfer the ownership of the object to the sender address. **Don’t worry**, if you don’t understand it well yet, we will look into transfer operations and object ownership in detail in upcoming lessons.

**Note:** `init` is not compulsory in a `module`, you can also define your function as the form of constructor when you need to return anything.

## Complete basic structure of Move on Sui Contract

So, we have covered essential components of the Move on Sui contract. These are not all of the things that help build a contract in Move on Sui, but it is a good start to understand the essential concepts we need to build a contract. So here’s what the complete structure looks like.

```
module package_name::module_name {
		use sui::object::UID;

		struct StructName has key {
		    id: UID,
		    // struct contents goes here
		}

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

		// module code goes here

}
```

## Other essential stuff a module needs to create a complete contract

Like any other programming language, we need to learn how you can write, create, and work with following different coding aspects:

1. Variables
2. Control flows
3. Expressions and operations
4. Functions
5. Advanced objects concepts
6. and many other

In upcoming lessons, we will cover all of these concepts in detail.

## That’s a wrap

Now, you know what the basic structure of the contract looks like in Move on Sui. Next, we will cover the basics of Move on Sui, starting with variables, data types, control flow, and different operations we can perform in Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/3.%20Move%20on%20Sui%20Package%20Architecture/3.%20Basic%20Module%20Structure%20in%20Move%20on%20Sui%20-%20II.md

Basic Module Structure in Move on Sui - II

nobrain

Andre

jason

Move on Sui Package Architecture

Dive into the fundamentals of Move. Gain insights into variables, data types, control flow, expressions, scope, and operators in Move on Sui

# How to Declare Variables and Constants?

In the last section, you learned all about the architecture of the Move on Sui package and you got the basics of how a smart contract is structured in Move on Sui. Now, we will explore more basics of the Move on Sui.

## `let` keyword

In Move on Sui, we use the `let` keyword to declare and initialize the variables. After declaring the variable, you can easily access and modify it later. There are several ways to declare and initialize the variable using the `let` keyword.

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

Let’s look at some examples now. No need to worry about types, we will discuss them in a few minutes. Remember, it is compulsory to add semicolons in Move on Sui.

```
let a;
let b : u8;
let c = true;
let d : u8 = 10;
```

Simple, isn’t it? Remember we declared an object using the `struct` keyword, but to initialize the object we need to use the `let` keyword. Here’s an example:

```
module hello_world::hello_world {
	// Importing object module
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring HelloWorldObject
	struct HelloWorldObject has key {
		id: UID,
	}

	// Initializing the constructor
	fun init(ctx: &mut TxContext) {
		// Initializing the HelloWorldObject using let keyword
		let object = HelloWorldObject {
			id: object::new(ctx),
		}
	}
}
```

- **Note:** The examples are not executable, they are given to help you understand the usage of different concepts.

Did you notice how we used the `let` keyword to initialize the object inside of the constructor function? We used `object::new(ctx)` to initialize the object using the `object` module.

## `const` keyword

In Move on Sui, the `const` keyword is used to declare and initialize the constants. We can define the constants at the module level, meaning they can be initialized outside of functions and can be used anywhere in the module. Here’s how to initialize the constant.

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

Constants can be defined using any data type. Here are some of the important pointers to know about the constants.

1. Constants cannot be changed once they are defined.
2. They cannot be accessed out of their module.
3. They are mostly used to define the module level constant value which cannot be changed and accessed anywhere in the module.

Here’s an example.

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

	public fun is_max(num: u64): bool {
		num == MAX
	}

}
```

## That’s a wrap

Variables and constants play an important role in Move on Sui. They are used to define the objects and store crucial information. Next, we will explore different data types we can use in Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/4.%20Move%20on%20Sui%20Basics/1.%20How%20to%20Declare%20Variables%20and%20Constants.md

How to Declare Variables and Constants?

# What are the Different Data Types?

Now that you have covered how you initialize variables and constants in Move, let’s cover what type of data types you can use to define those variables and constants. Let’s dive into them.

## Unsigned integer types

Here are the following unsigned integer types you can use in the Move.

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

Now, let’s look at an example to learn how to use them in code.

```
let a : u8 = 100;
let b : u64;
b = 300
```

Here’s how you can use data types in Move.

```
module examples::integers {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring the ExampleObject
	struct ExampleObject has key {
		id: UID,
		a: u8,
		b: u16
	}

	// Initializing the constructor
	fun init(a: u8, b: u16, ctx: &mut TxContext) {
		let object = ExampleObject {
			id: object::new(ctx),
			a: a,
			b: b,
		}
	}
}
```

In this example, we declared the `a` and `b` with `u8` and `u16` data types in the object, `ExampleObject`, and then initialized them in the `init` constructor.

## Boolean

In Move on Sui, the boolean works the same as in other programming languages. It has two values: `true` and `false`. Let’s look at how you can work with them in code.

```
let a = true;
		 
let b : bool; b = false;

let c : bool = true;
```

Here’s how you can use them in Move on Sui.

```
module examples::boolean {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring the ExampleObject
	struct ExampleObject has key {
		id: UID,
		a: u8,
		flag: bool,
	}

	// Initializing the constructor
	fun init(a: u8, flag: bool, ctx: &mut TxContext) {
		let object = ExampleObject {
		id: object::new(ctx),
			a: a,
			flag: flag,
		}
	}
}
```

In this example, we declared the `a` with `u8` and `b` with `bool` data type in the object, `ExampleObject`, and then initialized them in the `init` constructor.

## Vectors

Vector is a data structure that works like an array in Sui Move. To use a vector, we import a module,  `std::vector`, and use `let` to declare it. The format of a vector is like this: `vector<T>`, where `T` is any data type. Here’s how you can declare an empty vector is Move.

```
module examples::boolean {
	use std::vector;

	let v = vector::empty<u8>();
}
```

In Move, the most common use of `vector` is using `vector<u8>`, which is used as a byte type string to define or use the characters type variable.

## Strings

In Sui Move, you need an external module `std::string` to work with strings and define a string type data type to a variable. Let’s look at how you can work with them.

```
module examples::strings {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// std::string import
	use std::string::{Self, String};

	// Declaring the ExampleObject
	struct ExampleObject has key {
		id: UID,
		name: String,
	}

	// Initializing the constructor
	fun init(name_bytes: vector<u8>, ctx: &mut TxContext) {
		let object = ExampleObject {
			id: object::new(ctx),
			name: string::utf8(name_bytes)
		}
	}
}
```

Here, we did typecasting to store the string in the `name`. We used `vector<u8>` to fill the `name` string by type casting using the `string::utf8()` method. 

## Addresses

In Sui Move, you can initialize the variable with the address using the `@` symbol. Here’s how you can do that.

```
let addr = @0x2;
```

Here, `0x2` is an address, and `@` helps identify that it is an address. Now, let’s look at the different forms of format in which you can write an address.

1. `@0x1`: This is a short form of `0x00000000000000000000000000000001`.
2. `@0x42`: This is a short form of `0x00000000000000000000000000000042`.
3. `@0xDEADBEEF`: This is a short form of `0x000000000000000000000000DEADBEEF`.
4. `@0x0000000000000000000000000000000A`: This is a complete form of address.
5. `@std`: This will point to the address of `std`.

To pass the addresses to a function or define an address in the object, you need a keyword called `address` in Move. Here’s how you can do that.

```
module examples::address {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// std::string import
	use std::string::{Self, String};

	// Declaring the ExampleObject
	struct ExampleObject has key {
		id: UID,
		addr: address,
	}

	// Initializing the constructor
	fun init(add: address, ctx: &mut TxContext) {
		let object = ExampleObject {
			id: object::new(ctx),
			addr: add
		}
	}
}
```

In this example, we declared the `addr` with `address` in the object, `ExampleObject`, and then initialized them in the `init` constructor.

## Small challenge

Create a `module` that has an object named `Person`, and add `name`, `city`, `age`, and `date_of_birth` properties to it. Then create a constructor function that creates an instance of a `Person` object. Try creating your own smart contract and share the code with us in the assessment section.

## That’s a wrap

In this lesson, we covered various examples. Would you like to try running them on your system? Here's what you can do: create a new module named `examples` and then create different packages such as `integers`, `strings`, `vector`s, and `address`es. Finally, use the `sui move build` command to run them all and see what happens. If you come across any errors, try fixing them too.

Integers, boolean values, strings, vectors, and addresses are the primary data types that you will use frequently when using Move on Sui. These data types will assist you in constructing the foundations and beginning to program your first application. Following that, we will delve into control flow and learn how to work with these data types in Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/4.%20Move%20on%20Sui%20Basics/2.%20What%20are%20the%20Different%20Data%20Types.md

What are the Different Data Types?

# How Control Flow Works in Move on Sui?

Let's move forward and learn how to use different conditions in Move on Sui. In this lesson, we will explore if-else conditions and how to work with them like any other programming language. Additionally, we will review how you can work with variables in Move on Sui, which will help you understand the logic behind if-else conditions.

It's worth noting that Move on Sui avoids using for-while loops, as they can cause non-termination or infinite execution, which goes against the language's goal of being deterministic and predictable. Instead, iterative logic is implemented using recursion and pattern matching. Let's take a closer look.

## The `if` Expression

`if` expression allows you to run a block of code given some condition you have stated is true. If the condition is false, it will move to another code block. `if` is an expression and so it should end with a semicolon. Its syntax is as follows: 

```
if (<bool_expression>) {
	<expression> 
} else {
	<expression>
};
```

Let’s see an example in action using the `if` expression: 

```
module examples::if {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring the ExampleObject
	struct ExampleObject has key {
		id: UID,
		num: u8,
	}

	// Initializing the constructor
	fun main(ctx: &mut TxContext) {

		// Try switching to false
		let a = true;
		let b = if (a) {
			10
		} else {
			20
		};
		
		let obj = ExampleObject{
			id: object::new(ctx),
			num: b,
		}

	}
}
```

In the above example, if `a` is `true`, the variable `b` is set to `10` and if `a` is `false`, the variable `b` is set to `20`. This is achieved using the `if` expression. At last, we set the `num` of the `ExampleObject` field to the value of `b`.

**Note:** The return type in if-else must be the same. Otherwise, it will cause an error, and variable b will have the option to be some other type or undefined.

You can also use solo `if` - an `if` without the `else` condition. Here’s how you can use it in code.

```
module examples::if {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring the ExampleObject
	struct ExampleObject has key {
		id: UID,
		num: u8,
	}

	// Initializing the main function
	fun main(ctx: &mut TxContext) {

		// Try switching to false
		let a = true;
		let b = if (a) {
			10
		};

		let obj = ExampleObject{
			id: object::new(ctx),
			num: b,
		}

    }
}
```

Note that using a solo if condition to assign a `false` value to `a` can result in `b` being undefined, which may cause issues in your code. Therefore, it is recommended not to use a solo `if` condition.

## Using the built-in `assert` function

`assert` function comes in quite handy in Move on Sui. It is used when we want to abort the program if a certain condition is not met. Here’s the basic structure of writing the `assert` function.

```
assert!(condition, 0);
```

Here’s how you can use it in code.

```
module examples::assert {
	fun main(a: bool) {

		assert!(a == true, 0);
		// code here will be executed if (a == true)
    }
}
```

The program will first check if the condition, `a == true` is met, if true the rest of the condition will be met, if not the program will abort.

## Recursion in Move on Sui

So, as we have told you before Move on Sui does not use for-while loops, it does use the recursive functions. A recursive function does not allow you to run a program infinite times. It is bound to meet a certain condition and end the program. Let’s look at how you can calculate a factorial of a number in Move on Sui.

```
module examples::assert {
	fun factorial(n: u64): u64 {
		if (n == 0) {
			return 1;
		} else {
			return n * factorial(n - 1);
		}
	}
}
```

The function uses an if-else statement to check the base case `(n == 0)` and the recursive case (`n * factorial(n - 1)`). This ensures that the function will always terminate and return a value.

## That’s a wrap

Knowing to work with different conditions in Move on Sui gives you an opportunity to cater to different conditions you’ll need to write your smart contracts. It also allows you to write multiple math conditions you would need to develop games etc. For example, building your own random number generator on Sui Move. Next, we will explore certain expressions and operators you can perform in Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/4.%20Move%20on%20Sui%20Basics/3.%20How%20Control%20Flow%20Works%20in%20Move%20on%20Sui.md

How Control Flow Works in Move on Sui?

# Move Expressions, Scope, and Operators

We have covered many concepts of Move on Sui. Move on Sui also offers various expressions. Let’s dive into learning about them as well as how scopes work in Move on Sui.

## Sui expressions

A code unit that returns something or a statement that ends with a semicolon is an expression. That something could be an integer, a string, a boolean, or any valid data type. We can safely say that functions are expressions as they return a value.

Move on Sui has 3 types of expressions:

- Empty
- Literal
- Block

Let’s explore these expressions with examples:

### Empty expression

We might never use this expression directly but it’s always good to know that we have an option of an empty expression.

Just add an empty parenthesis in the function body for an empty expression. These are automatically omitted by VM so no extra cost in defining these. 

```
fun function_name() {
	() 
}
```

### Literal expressions

We learned to define variables and constants, right? 

And the good news for you is defining them and ending them with a semi-colon makes it an expression.

Following are the examples that we used in the lesson Variables and Constants. All of these are literal expressions. Phew! Wasn’t it so easy 😃

```
let a;
let b : u8;
let c = true;
let d : u8 = 10;
```

- The simplest expressions can be `10 + 5;` or even `2;` . We actually use them for defining the variables or constants.

### Block expression

A block marked by `{}` is an expression. Block can have expressions or other blocks in it. And it may or may not return a value. If it's the return value of the block, it’s not necessary that it ends with a semicolon.

```
module examples::example {
	fun function_name() {
		// this is a block
		{ }; // this too
		{ 3; // a block
			{true;} // another expression in a block
		}
	}
}
```

## Scope in Move

Since we talked about block expressions, we also need to learn what’s in store about Scope in it. Like by definition scope means the area where a certain variable lives or exists. It means whenever we are defining a block using `{}`, we are defining a scope. So all the variables we will define in that scope are accessible but outside that scope, we cannot call them.

I know this might be confusing you, so let me make it easy for you by explaining it using an example:

```
module examples::example {
	fun function_name() {
		// This is the scope of a function - Block A
		let a = 0;

		{
			let b = 0; 
		}; // this is a scope within a function- Block B

		{ // Block C
			let c = 0;
			{let flag = true;} // this is a nested scope - Block D
		}
	}
}
```

Considering the above example, we can note some points:

- Anything defined in Block A will be accessible to Block B, C, and D. It means we can access `a` anywhere in the `function_name` function.
- Anything defined in Block B is inaccessible to Blocks A, C, and D. It means we cannot access `b` anywhere else.
- Anything defined in Block C is inaccessible to Block A and B but accessible to Block D as it's nested in Block C. It means we cannot access `c` anywhere else except Block C and D.
- Anything defined in Block D is inaccessible to Blocks A, B, and C. It means we cannot access the `flag` anywhere else except Block D not even Block C.

Let me sum all of this explanation into one line for you. ***The variable can only live within its scope or block where it is defined.***

Since we are done with expressions and scope. Now let’s quickly see what operators we have in Move on Sui for integers.

## Move Operators

Move on Sui has various operators including the following for uint: `u8`, `u64`, `u128`.

Move has a variety of operators to modify integer values. Here's a list:

| Operator | Operator name |
| --- | --- |
| + | sum |
| - | sub |
| / | div |
| * | mul |
| % | mod |
| << | lshift |
| >> | rshift |
| & | and |
| ^ | xor |
| | | or |

## _ is something unique

Sui Move doesn’t allow you to declare a variable that you do not utilize and it will throw you an error. So efficient, isn’t it?

But if we for some reason have to define a value, we do have a cheat door for it 😏.

Consider the following code:

```
module examples::example {

	fun add() {
        let sum = 1;
    }
}
```

This will throw an error since we are not using `sum` anywhere else. But if replace `sum` with `_` as shown below, we will not receive an error. Coool!!

```
module examples::example {

	fun add() {
        let _ = 1;
    }
}
```

## Wrap up

In this lesson, we covered expressions in Move, including empty expressions, literal expressions, and block expressions. We also learned about scopes and how they define variable accessibility. Understanding expressions and scopes is crucial for writing effective code in Move on Sui. At last, we learned about the operators available in Move on Sui for integers and explored a unique aspect of Move on Sui. By understanding these operators, we can start writing basic code.

Keep practicing and exploring Move on Sui as you continue your programming journey!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/4.%20Move%20on%20Sui%20Basics/4.%20Move%20Expressions%2C%20Scope%2C%20and%20Operators.md

Move Expressions, Scope, and Operators

Mohammed

niggamani

Daniel Bueno

Move on Sui Basics

Explore the functions in Move thoroughly, go through different examples, and understand the visibility specifiers of Sui Move.

# Functions Basics

Now that you have covered all the basics of Sui Move, let’s dive straight into learning how you can work with functions in Sui Move.

## Function definition

In Sui Move, the function is where the execution happens. You can define functions using the `fun` keyword. You might have noticed that the constructor function is also defined using the `fun` keyword. Let’s look at how you can define a function in Sui Move.

```
fun function_name() {
	// Function code goes here
}
```

This is the simplest way to write the function, where there is no argument or return type mentioned.

## Function in module

As you know, we write everything inside of a module in Sui Move. Now, let’s look at how it is structured inside of the module using an example.

```
module examples::example {

	fun add(num_1: u64, num_2: u64) {
		let sum = num_1 + num_2;
	}
}
```

Here, we didn’t return only only passed the arguments and added them.

## Function arguments

As you can see, like all other programming languages you can pass arguments to the functions. The format of passing the argument is `variable_name: data_type`. You can either pass no argument or more than one argument to the function. Let’s at the coding example.

```
module examples::example {
	fun function_name(argument_1: u8, argument_2: u8) {
		// Function code goes here
	}
}
```

The function arguments are defined within the scope of the function. When the function gets destroyed, the arguments get destroyed. Here are the basic syntax pointers for passing the function arguments.

1. Multiple arguments are separated using commas.
2. All of the arguments are defined inside of the parenthesis.

## Function return

As we all love returning values from the functions, Sui Move can also do that. To define the return type of a function, we mention the data type out of the parenthesis: `fun fun_name(): data_type {}`. Let’s look at the coding example.

```
module examples::example {
	fun function_name(argument_1: u8, argument_2: u8): u8 {
		// Function code goes here
	}
}
```

Now, how do we return a value from the function? To do so we don’t need a `return` keyword in Sui Move. We just write an expression, a variable name, and a function name that returns any value without any other keyword at the end of the function. Let’s at the coding example.

```
module math::math {
	fun sum(a: u8, b: u8): u8 {
		a + b
	}
}
```

Here, the `sum` function returns the value of `a + b`. Let’s look at another example.

```
module examples::strings {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// std::string import
	use std::string::{Self, String};
		
	// Declaring the Name
	struct Name has key {
		id: UID,
		name: String,
	}

	// Initializing the constructor
	fun fill_name(name_bytes: vector<u8>, ctx: &mut TxContext): Name {
		Name {
			id: object::new(ctx),
			name: string::utf8(name_bytes)
		}
	}
}
```

In this case, the `fill_name` function will return an object, `Name`.

## That’s a wrap

Functions play an important role in any programming language. So it is important to learn how each programming language works with functions. Next, we will explore the visibility specifiers for functions to cover the advanced topics to work with functions in Sui Move.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/5.%20Move%20on%20Sui%20Functions/1.%20Functions%20Basics.md

Functions Basics

# What are the Different Visibility Specifiers?

Now that you have gone through the basics of functions, let’s dive a bit further and explore different aspects of functions in Sui Move.

## Functions visibility

Visibility means how functions can be accessed out of the module they were defined in. For example, if any other module can access the function or not. So, in some cases, developers might want the functions outside of their specific module, and in some cases not. So, to handle this we have two most popular visibility specifiers: Private and Public.

### Private functions

By default the function visibility is set to private, meaning the function will only be accessible by the same module but not accessible outside of the module. Let’s look at the following example.

```
module examples::math {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// std::string import
	use std::string::{Self, String};

	// Declaring the Name
	struct Numbers has key {
		id: UID,
		a: u8,
		b: u8,
	}

	// Initializing the constructor
	fun init(a: u8, b: u8, ctx: &mut TxContext) {
		let numbers = Numbers {
			id: object::new(ctx),
			name: string::utf8(name_bytes)
		}
	}

	fun add(n: Numbers) {
		let sum = n.a + n.b;
	}
}
```

Here, by default, `add` is the private function.

### Public functions

You can use the `public` keyword with the Sui Move functions to make them public. Public functions are accessible outside of the module, meaning other modules (Aka their functions) can also access the public functions. Let’s add a public function to our last example.

```
module examples::math {
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// std::string import
	use std::string::{Self, String};

	// Declaring the Name
	struct Numbers has key {
		id: UID,
			a: u8,
			b: u8,
	}

	// Initializing the constructor
	fun new(num_1: u8, num_2: u8, ctx: &mut TxContext) {
		let numbers = Numbers {
			id: object::new(ctx),
				a: num_1,
				b: num_2,
		}
	}

	fun add(n: Numbers) {
		let sum = n.a + n.b;
	}

	public fun sub(n: Numbers){
		let result = n.a - n.b;
	}
}
```

Now, by putting the `public` keyword before the `fun` keyword, we have made the `sub`-function a public function that can be accessible outside of the module.

## Entry functions

In Sui Move, one of the basic operations is gas object transfer between addresses representing individual users. And when you make a transaction, the `entry` function is something that is called directly. To initialize an `entry` function, we need to make sure following three things.

1. The function should be marked by the `entry` keyword.
2. It should have no return value.
3. The last parameter of the entry function must be a `TxContext` mutable reference to an instance of the type.

Let’s take an example from our “Hello World” program, that we discussed at the start of the course.

```
public entry fun mint(ctx: &mut TxContext) {
    let object = HelloWorldObject {
        id: object::new(ctx),
        text: string::utf8(b"Hello World!")
    };
    transfer::public_transfer(object, tx_context::sender(ctx));
}
```

Now, this function will be executed at the time of the transaction, and `&mut TxContext` is a mutable reference that will help identify the sender’s address who wants to mint the contract. The `transfer` module at the end of the function does not return any value but helps store the object in the Sui global storage that you can access globally after deploying the module. Don’t worry we will discuss the “Hello World” program in detail by the end of the course.

## That’s a wrap

Functions visibility and entry functions play a crucial role in Sui Move. By understanding them you have become a superhero. Now, we need to dive deeper into the Sui Move objects. Let’s dive into it.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/5.%20Move%20on%20Sui%20Functions/2.%20What%20are%20the%20Different%20Visibility%20Specifiers.md

What are the Different Visibility Specifiers?

Dude

Predator

sdfghdh

Move on Sui Functions

Understand the types of abilities in Move thoroughly and discover how to work with them through examples.

# Custom Types and Abilities

Congratulations on completing the half of the course. You are doing great so far. In this lesson, we will explore the abilities—the abilities actually help give the ability to any type to perform different functionalities. Let's explore them in detail.

## What exactly are abilities?

In the Move programming language, abilities are like special rules that decide what you can do with certain types of information or values. Think of it as setting permissions for what actions you can take—like sharing a document or making edits to it.

This system is pretty detailed and allows you to be very specific about how these values behave. For instance, it can manage whether a value can be copied or saved somewhere permanently.

To make this work, Move uses a kind of checkpoint system. Some of the basic commands in the language, which we call "bytecode instructions," require a value to have the right "permission slip" (or ability) before it can be used. However, not all commands are strict; some don't need this special permission.

So, in simpler terms, abilities in Move help keep a tight check on what each piece of data can do and where it can go, making sure everything is used in the right way.

## Abilities syntax

To add the abilities to types, you add the abilities to `struct` and need to use the following syntax.

```
 struct StructName has ABILITY [, AnyOtherAbility] { [FIELDS] }
```

Here’s how the example code looks like.

```
struct Color has key, store {
	id: UID,
	red: u8
}
```

## Different types of abilities

There are four types of abilities.

1. `copy`: This ability allows values to get copied.
2. `drop`: This ability allows values to get dropped or popped.
3. `store`:  This ability allows values to exist inside the struct in global storage.
4. `key`: This ability allows the types to serve as a key for global storage.

Let’s discuss them one by one.

## Key

The `key` ability allows the type to serve as a key for global storage operations. This means to perform certain operations for global storage we must add `key` ability to the type. If the struct has a `key` ability it means all of its fields have a `store` ability. Here’s how we can use it in code in Move on Sui.

```
module examples:: copy {
	// Importing object module
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring ExampleObject
	struct ExampleObject has key {
		id: UID,
	}

	// Initializing the constructor
	public entry fun new(ctx: &mut TxContext): ExampleObject  {
		// Initializing the ExampleObject using let keyword
		let object = ExampleObject {
			id: object::new(ctx),
		}
	}

}
```

### Store

The `store` ability is an important ability in Move on Sui. It is a good practice to add a `store` alongside the `key` in Move on Sui. The store ability allows the struct and its fields to exist in a global storage. This is the only ability that does not need an operation to be performed but it automatically gates the types’ existence in global storage when used with `key` ability. Here’s how we can use it in code in Move on Sui.

```
module examples:: copy {
	// Importing object module
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring ExampleObject
	struct ExampleObject has key, store {
		id: UID,
	}

	// Initializing the constructor
	public entry fun new(ctx: &mut TxContext): ExampleObject  {
		// Initializing the ExampleObject using let keyword
		let object = ExampleObject {
			id: object::new(ctx),
		}
	}

}
```

In Move on Sui, `key` ability is compulsory to use but it is optional to use the `store` ability.

### Copy

The copy ability gives objects the ability the be copied. This means it gives an object the ability to make a copy itself using the `copy` operator. Let’s look at how it can be used in code.

```
module examples:: copy {
	// Importing object module
	use sui::object::UID;
	use sui::tx_context::{Self, TxContext};

	// Declaring ExampleObject
	struct ExampleObject has key, copy {
		id: UID,
	}

	// Initializing the constructor
	public entry fun new(ctx: &mut TxContext): ExampleObject  {
		// Initializing the ExampleObject using let keyword
		let object = ExampleObject {
			id: object::new(ctx),
		}
		// Copying the `object` using `copy` operator 
		let copy_object = copy object;
		copy_object;
	}

}
```

### Drop

The `drop` ability allows us to drop the types. This means the types get destroyed as the Move program gets executed. The struct with drop ability means all of the instances of the struct get dropped. But Move on Sui, objects have a UID and we cannot drop the UID simply using the `drop` operator.  

## That’s a wrap

Understanding the abilities was crucial because they are widely used in Move on Sui. You must have noticed in previous examples as well that we were using key and store ability often. So now you understand why we were using them. Next, we will move to understand objects in detail and we will see more use cases of ability.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/6.%20Move%20on%20Sui%20Types%20With%20Abilities/1.%20Custom%20Types%20and%20Abilities.md

Custom Types and Abilities

coded

lucky

Move on Sui Types With Abilities

Delve into the details of objects, beginning with the basics. Understand how to use them and grasp the concept of ownership through practical examples.

# Basics of Objects in Move on Sui

I’m so proud of you for coming this far and completing all of the basics of Move on Sui. As you have already been introduced to the objects and how you declare and initialize them, now we will learn them in detail from the start and dive further to understand them better.

## Let’s recall, what is the Move on Sui object?

In simple language, an object in Move on Sui is like a container that holds data. 

As we have discussed before, to make an object in Move on Sui, you need to define its structure using something called a `struct`. A `struct` is like a blueprint that describes what information the object will hold. For example, the `struct Sum` has fields for `number_1` and `number_2` values.

```
struct Sum {
    number_1: u8,
    number_2: u8,
}
```

Did you catch the mistake here? Yes, you’re right. This is not a Move on Sui object. To make it a Move on Sui object we need to add an ability, `key`, and ID using `sui::object::UID` to give a unique ID to each object that helps identify the object on the Sui network. Now, let’s make our `Sum` struct a Move on Sui object.

```
use sui::object::UID;

struct SumObject has key {
    id: UID,
    number_1: u8,
    number_2: u8,
}
```

Remember, we need to write all the code inside of the `module` in Move on Sui? This is your task to write all the code inside of the `module` and see what it looks like.

## Create objects in Move on Sui

So, now you know how you can define an object in Move on Sui, but how can you initialize it? We have gone through this in previous lessons as well, but let’s recall as it is important to remember all about the objects as if our life depended on them. 

So, to create an object we must fill all of the fields with the values that we have defined inside of the object. To do so, first of all, we need to assign a value to `id`. As the `UID` defines the data type of `id`, we need to fill the `id` with a unique ID. Here’s where `sui::object` and `sui::tx_context` modules come in handy. `sui::object` helps us call the `new()` function that instantiates the new id with the value that `sui::tx_context` gave us. Let’s look at an example first, then we’ll understand this further.

```
module sum::sum {
		use sui::object;
		use sui::tx_context::TxContext;

		// Defining the SumObject
		struct SumObject has key {
		    id: UID,
		    number_1: u8,
		    number_2: u8,
		}
		// Constructor function used to iniatlize the SumObject
		fun new(num_1: u8, num_2: u8, ctx: &mut TxContext): SumObject {
				SumObject {
		        id: object::new(ctx),
		        number_1: num_1,
				    number_2: num_2,
		    }
		}
}
```

Did you notice how `TxContext` played its part in this example? Yes, you have seen this syntax in previous examples as well, but let’s go through this again because this is like flour in the cake. And without the flour, we cannot make the cake. Bad example we suppose, but you got the idea right?

So, `TxContext` gives us the information of the transaction, and `&mut` makes it mutable and then we pass `ctx` to the `object::new()` function to create a new instance of `UID`.

## Store object in Move on Sui

So, you have initialized the object, but where does it get stored? When you initialize the object inside of the constructor it is stored locally meaning it can be returned from the current function, passed to another function as a parameter, or stored inside of another struct. But what if we want to access the object from another module or view it at a global level for example on Explorer? As there is no print system in Sui, we need to find a workaround to do.

So, to do this we use a `transfer` module. The `transfer` module helps add the object to the persistent storage. It has all of the functionalities that help to do this. Here’s how the format of using the `transfer` module looks like.

```
transfer::function_call(object, recipient)
```

This is the simplest representation of using the `transfer` module. We use this line inside of the function and add the object in global storage where the recipient is the owner of the object, where the owner can be an address, another object, or a shared object. **Don’t worry!** We will talk about object ownership in detail in upcoming lessons.

The common use of this module is to transfer the ownership of the object to the one who called the contract, here we call it a sender or the signer of the current transaction such as minting an NFT that is owned by you. So, how can we get the information of the sender? In Move on Sui, the only way to get the information is to use the entry function, which has the last argument as transaction context, `ctx: &mut TxContext`, which gives us all of the information of the current transaction. 

So, to obtain the current transaction signer we call something like this: `tx_context::sender(ctx)`. Let’s look at the complete working of the transfer module using the following example.

```
 module sum::sum {
		use sui::object;
		use sui::tx_context::TxContext;

		// Defining the SumObject
		struct SumObject has key {
		    id: UID,
		    number_1: u8,
		    number_2: u8,
		}
		// Constructor function used to iniatlize the SumObject
		fun new(num_1: u8, num_2: u8, ctx: &mut TxContext): SumObject {
				SumObject {
		        id: object::new(ctx),
		        number_1: num_1,
				    number_2: num_2,
		    }
		}

		// create function is used to call the constrcutor function and 
		// transfer the ownership of the object and make it public using
		// `transfer` module and function.
		public entry fun create(red: u8, green: u8, blue: u8, ctx: &mut TxContext){
			let Color = new(red, gree, blue, ctx);
			transfer::transfer(color_object, tx_context::sender(ctx))
		}
}
```

Here, we used `the transfer::transfer(color_object, tx_context::sender(ctx))` line to make the `SumObject` public as well as assign and transfer its ownership to the `sender` address.

Did you get the idea of why we were using this line in our “Hello World” program? 

## Challenge

So, here’s the small challenge for you. Write an `animal` contract, which has an `AnimeObject` with `name`, `no_of_legs`, and `favorite_food` properties. Create a constructor function and then transfer the ownership of the `AnimeObject` object to the `sender` address.

After creating the contract try deploying it on the Sui blockchain and explore what happens.

## That’s a wrap

You have covered the basics of objects in this lesson. Now, you know very well how to declare and work with an object in Move.

Completing the challenge will help you equip what you have learned faster. Please do complete it and after completing the challenge share the screenshot of the code with us. In the next lesson, we will explore more advanced concepts of using the Move on Sui object, so it is important to practice the basics first.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/7.%20Objects%20in%20Move%20on%20Sui/1.%20Basics%20of%20Objects%20in%20Move%20on%20Sui.md

Basics of Objects in Move on Sui

# Using Objects in Move

Last, we covered how to define, create, and take ownership of the Sui object in Move. Now, we need to learn how to use the objects. Let’s learn it in detail.

In Move on Sui, you can only call the object you own. To use the objects, you need to pass them as parameters to the `entry` function. Now, let’s first look at two different ways to pass the objects as parameters: by reference and by value.

## Pass objects by reference

There are ways to pass the objects by reference.

1. `&T`: Read-only reference
2. `&mut T`: Mutable reference

Here, `T` represents anything we’re passing by reference, and `&` symbol is used to tell that the object is passed by reference. Let’s look at how they work.

### Read-only reference

The read-only references only allow you to read the data of the object. It doesn’t allow you to change or update the data of the object. Let’s take an example we used in the last lesson to clarify how it can be used in code.

```
module sum::sum {
		use sui::object;
		use sui::tx_context::TxContext;

		// Defining the SumObject
		struct SumObject has key {
		    id: UID,
		    number_1: u8,
		    number_2: u8,
		}

		// Constructor function used to initialize the SumObject
		fun new(num_1: u8, num_2: u8, ctx: &mut TxContext): SumObject {
				SumObject {
		        id: object::new(ctx),
		        number_1: num_1,
				    number_2: num_2,
		    }
		}

		// make_copy function that uses the values data of obj to create a new object
		public entry fun make_copy(obj: &SumObject, ctx: &mut TxContext) {
				let sum_obj = new(obj.num_1, obj.num_2, ctx);
				transfer::transfer(sum_obj, tx_context::sender(ctx))
		}
}
```

Here, in the `make_copy` function, we are using the `obj` object in a read-only form and using it to create and update the data values of a new object, `sum_obj`.

### Mutable Reference

So, the mutable reference is the opposite of the read-only reference. The mutable reference allows you to mutate the data in the object, and change the data of the fields of an object. Let’s look at an example code to understand how mutable references work.

```
module sum::sum {	
		use sui::object;
		use sui::tx_context::TxContext;

		// Defining the SumObject
		struct SumObject has key {
		    id: UID,
		    number_1: u8,
		    number_2: u8,
		}

		// copy_into function uses the properties data of obj_1 (non-mutable)
		// to update the data of obj_2 (mutable)
		public entry fun copy_into(obj_1: &SumObject, obj_2: &mut SumObject, ctx: &mut TxContext) {
				obj_2.num_1 = obj_1.num_1;
				obj_2.num_2 = obj_1.num_2;
				transfer::transfer(obj_2, tx_context::sender(ctx))
		}
}
```

Here, `obj_1` is a read-only object and `obj_2` is a mutable reference. We are updating the data properties of `obj_2` with the properties of `obj_1`. After updating the `obj_2` properties we are changing the ownership of the `obj_2` using `the transfer` module. Declaring the function with an entry modifier makes the function callable for the transactions. But we’ll have to make sure that the sender of the transaction must own both `obj_1` and `obj_2`.

## Pass objects by value

A second way to use the objects is to pass the objects by value to a Move `entry` function. This makes the object not get stored in the Sui storage and the code can decide where should the object be stored. Let’s look at how an object can be passed by value in Move on Sui.

```
module sum::sum {	
		use sui::object;
		use sui::tx_context::TxContext;

		// Defining the SumObject
		struct SumObject has key {
		    id: UID,
		    number_1: u8,
		    number_2: u8,
		}

		// Passing the object by value
		public entry fun update_num_1(num_1: u8, object: SumObject): SumObject {
			let obj = object;
			obj.number_1 = num_1;
			obj
		}
}
```

Here, we are passing the `object` by value, creating a new object, `obj`, updating the `number_1` value, and then returning the new object.

The issue of passing the object by value is when we pass the object, it creates a new instance of the object in the memory and does not get deleted until we don’t delete it on our own.

As you have learned each Move on Sui object should have the `UID`, the `UID` struct does not have the `drop` ability which makes Move on Sui in general not use the `drop` ability anywhere. So, what can we do if we want to free up the space in the memory storage? To handle the pass-by-value objects we have two ways to do so.

1. Delete the object
2. Transfer the object

Let’s go through them one by one.

### Delete the object

So, if you decide to delete the object, we need to do the unpacking. You cannot directly delete the object. What you can do is unpack the field of the object, store all of the fields to the new variables, and assign them the garbage value. Let’s look at how you can do the unpacking.

```
let SumObject { id, number_1: _, number_2: _ } = object;
```

Here, we unpacked the object and made the `number_1` and `number_2` values free of any data using `_`. As we cannot free the `id` field, we need a little extra help with it. We use the `object::delete` function to delete the `UID` and free up the space. Remember, you can only delete the object inside of the module where you have defined the object. Let’s look at the complete coding example now.

```
module sum::sum {	
		use sui::object;
		use sui::tx_context::TxContext;

		// Defining the SumObject
		struct SumObject has key {
		    id: UID,
		    number_1: u8,
		    number_2: u8,
		}

		// Deleting the object
		public entry fun delete(object: SumObject) {
				let ColorObject { id, red: _, green: _, blue: _ } = object;
        object::delete(id);
		}
}
```

**Note:** We only delete objects passed by value and not objects passed by reference because if delete the referenced object it will get deleted from the global storage which we cannot afford to do. However, objects passed by value are the new instance of the original object. So it is important to clear the memory after we have used the object by value.

### Transfer the object

Another way to handle the object is to transfer it to another owner. So, to transfer the object we need to define the `transfer` function. Let’s look at how you can define it in the code.

```
public entry fun transfer(object: SumObject, recipient: address) {
    transfer::transfer(object, recipient)
}
```

Here, the `recipient` represents the address of the one we want to transfer the object to. Remember that you cannot call the `transfer::transfer()` outside of the `entry` function.

## That’s a wrap

I’m so proud of you for coming this far and learning all of the basics of Move on Sui. Next, we will dive further and learn how object ownership works and how you can change it.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/7.%20Objects%20in%20Move%20on%20Sui/2.%20Using%20Objects%20in%20Move.md

Using Objects in Move

# Objects Ownership

So far, you have explored all the basics of objects and how you can use them. We’re so proud of you for keeping your momentum going. Now, in this lesson, we will explore different object ownership methods that will help you define the security of your object.

## Object ownership

Object ownership defines how you can use an object while making a transaction. There are multiple types of object ownership. Here are these.

1. Address-owned
2. Dynamic fields
3. Immutable
4. Shared
5. Wrapped

Let’s explore them in detail one by one.

## Address-owned

An address-owned object is an object owned by a 32-byte address, which can be an account address or an object ID. The owner is the only one who has access to it. Here are two ways you can create an address-owned object.

```
sui::transfer::transfer(obj: T, recipient: address)
sui::transfer::public_transfer(obj: T, recipient: address)
```

1. Use the `sui::transfer::transfer` function if you are defining the custom transfer policy for the object, meaning it only has `key` ability and no `store` ability.
2. Use the `sui::transfer::public_transfer` to create the address-owned function if the object has the `store` ability.

You can use the address-owned object when you want to have only one owner of the object.

## Immutable objects

An immutable object is not mutable, meaning it has no owner, it cannot be transferred to anyone, and neither it can be deleted. Here’s how you can make an object immutable.

```
public native fun public_freeze_object(obj: T)
```

After the object becomes an immutable object, you cannot make it mutable. However, you can pass it as a parameter to a function as a read-only object using an immutable reference to an `entry` function.

## Shared object

A shared object is an object that is accessible to everyone. Compared to address-owned objects, shared objects are accessible by anyone on the network. Here’s how you can make a shared object.

```
transfer::share_object(obj: T)
```

## Wrapped objects

Like many programming languages, you can use a `struct` type instance inside of another `struct`. Here’s how you can do that.

```
struct Foo has key {
    id: UID,
    bar: Bar,
}

struct Bar has store {
    value: u64,
}
```

Here, the `Foo` Sui object with the `key` ability has an instance `bar` with a `Bar` data type, which is a `struct`. Here, the `Bar` is not a Sui object because it does not have a `key` ability. You can make it a Sui object and use it in `Foo` as well.

We learn more about object wrapping in upcoming lessons.

## Dynamic object fields

There are several ways to use the object fields to store different types of data. But there are several drawbacks to it:

1. When a module is published, objects have a fixed set of fields identified by keys in the `struct` declaration.
2. An object wrapping several others can increase gas fees and has size limits.
3. Storing a collection of objects of different types is not possible with the Move `vector` type, as it requires a single type `<T>`.

Here’s where dynamic fields come in.

## That’s a wrap

We’re so proud of you for learning the objects in detail. Next, we will explain the “Hello World” program in detail and then we will give an assessment to code your own smart contract on Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/7.%20Objects%20in%20Move%20on%20Sui/3.%20Objects%20Ownership.md

Objects Ownership

Ahmad

Glendell

Iqbal

Objects in Move on Sui

Discover the inner workings of the "Hello World" program and gain a comprehensive understanding of its code, analyzing it line by line.

# Understand the Hello World Program

We have run our Hello World program and interacted with [i](http://it.Now)t. As now we are done with the basics, we can dive into understanding the complete code of it.

## Complete code

The complete code of the Hello World program is:

```
// Copyright (c) 2022, Sui Foundation
// SPDX-License-Identifier: Apache-2.0

/// A basic Hello World example for Sui Move, part of the Sui Move intro course:
/// https://github.com/sui-foundation/sui-move-intro-course
/// 
module hello_world::hello_world {

    use std::string;
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    /// An object that contains an arbitrary string
    struct HelloWorldObject has key, store {
        id: UID,
        /// A string contained in the object
        text: string::String
    }

    public entry fun mint(ctx: &mut TxContext) {
        let object = HelloWorldObject {
            id: object::new(ctx),
            text: string::utf8(b"Hello World!")
        };
        transfer::public_transfer(object, tx_context::sender(ctx));
    }

}
```

## Explanation

Let’s dive into the line-by-line explanation of the code:

```
// Copyright (c) 2022, Sui Foundation
// SPDX-License-Identifier: Apache-2.0
/// A basic Hello World example for Sui Move, part of the Sui Move intro course:
/// https://github.com/sui-foundation/sui-move-intro-course
/// 
```

- The code begins with comments indicating its copyright (Sui Foundation) and the SPDX-License-Identifier, which specifies the Apache-2.0 license.

- `module hello_world::hello_world {`:The code defines a module named `hello_world` within the `hello_world` namespace.

```
    use std::string;
    use sui::object::{Self, UID};
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};
```

- The code imports various modules using the `use` keyword, including:
    - `std::string`: This is for using the string data type from the standard library.
    - `sui::object::{Self, UID}`: This imports the "Self" and "UID" types from the `sui::object` module.
    - `sui::transfer`: This imports the "transfer" module, for transferring objects.
    - `sui::tx_context::{Self, TxContext}`: This imports the "Self" and "TxContext" types from the `sui::tx_context` module, for handling transaction context.

```
    struct HelloWorldObject has key, store {
        id: UID,
        /// A string contained in the object
        text: string::String
    }
```

- Within the module, a struct named `HelloWorldObject` is defined. This struct represents an object with the following properties:
    - `id`: A unique identifier (UID) for the object.
    - `text`: A string containing some arbitrary text.

```
public entry fun mint(ctx: &mut TxContext) {
        let object = HelloWorldObject {
            id: object::new(ctx),
            text: string::utf8(b"Hello World!")
        };
        transfer::public_transfer(object, tx_context::sender(ctx));
    }
```

- A public entry function named `mint` is defined. This function takes a mutable reference to a `TxContext` as an argument.
- Inside the `mint` function:
    - It creates a new `HelloWorldObject` object.
    - The `id` field of the object is initialized using the `object::new` function, generating a new unique identifier.
    - The `text` field of the object is initialized with the text "Hello World!" using `string::utf8(b"Hello World!")`.
    - Finally, it transfers the `HelloWorldObject` to the sender using the `transfer::public_transfer` function. This suggests that the `mint` function is responsible for creating and transferring this object.

You have been doing awesome! I am sure now you can print any text that you want easily. So why don’t you mint your name and try running the code for that? Build and learn!

## Wrap it up

In summary, we analyzed a "Hello World" program in Sui Move, covering module imports, struct creation, and function definitions. Now, you're ready to modify the code and experiment. Remember, practice is the key to learning. Happy coding!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/8.%20Back%20to%20Hello%20World/1.%20Understand%20the%20Hello%20World%20Program.md

Understand the Hello World Program

Johnny

Siddharth

Satyam Mishra

Back to Hello World

Delve into the advanced concepts of Move, understanding how objects wrapping and events function on Sui.

# Object Wrapping

I’m so proud of you for coming this far in the course. You have covered all of the basics so far. Not only this, you have also understood how the “Hello World” program works. Now it is time to go a little further and cover some advanced topics. In this lesson, we will cover the object wrapping that will help you immensely when you dive into building your dApps on Sui.

## Object wrapping

In the Sui Move programming language, you can organize data structures by putting one data structure inside another through something called **wrapping**. Imagine this to be something like a toolbox holding different items inside it. In Sui Move, you can organize data structures by putting a field of `struct` type in another, like below:

```
struct Foo has key {
    id: UID,
    bar: Bar,
}

struct Bar has key, store {
    id: UID,
    value: u64,
}
```

For a struct to be a Sui object, it should have the `key` ability. Now if you put a Sui object of type `Bar` into a Sui object of type `Foo`, the object type `Foo` wraps the object type `Bar`. The object type `Foo` is the wrapper or wrapping object. 

In the Sui Move code, you can put a Sui object as a field of a non-Sui object struct type. 

- Imagine you have a struct called "Foo" that is not a Sui object, and another struct called "Bar" that is a Sui object with the "key" and "store" abilities. You can put "Bar" inside "Foo," but this is temporary and won't persist on the blockchain.
- When you wrap an object, it becomes part of the data of the wrapping object. This means you can't look it up by its unique ID, and you can't pass the wrapped object as an argument in your blockchain transactions. The only way to access it is through the object that wraps it.
- You can't create a situation where, for example, object A wraps object B, B wraps C, and C also wraps A. This would lead to complexity and issues in your code.
- You can "unwrap" the wrapped object. When you unwrap it, it becomes an independent object again and can be accessed directly on the blockchain. The object retains the same unique ID it had before wrapping.

There are a few common ways to wrap a Sui object into another Sui object. Let’s look at them below:

### Direct wrapping

If you put a Sui object type directly as a field in another Sui object type, it is called **direct wrapping**. In this type of wrapping, the wrapped object cannot be unwrapped unless the wrapping object is destroyed. It could be used to lock objects with limited access.

Let’s see an example. Say you have a type of NFT-style object in Sui called `Object`, which has properties like `scarcity` and `style`. To ensure that there is a fair trade, you need to make sure that the scarcity is identical and only styles are different. This is because the value of NFTs is higher if it has more scarcity.  Here's how you can implement it:

```
struct Object has key, store {
    id: UID,
    scarcity: u8,
    style: u8,
}

public entry fun create_object(scarcity: u8, style: u8, ctx: &mut TxContext) {
    let object = Object {
        id: object::new(ctx),
        scarcity,
        style,
    };
    transfer::transfer(object, tx_context::sender(ctx));
}
```

In the above code, you can create an Object with specified scarcity and style using the `create_object` function. Anyone can call it, and the created object is sent to the transaction sender.

Now, you might recall from the previous sections that only object owners can send a transaction to mutate the object. So one person cannot send a transaction that would swap their own object with someone else's object. Hence, anyone who wants to swap their objects needs to send their objects to a third party like a swapping site. To ensure that you retain custody of your objects (such as coins and NFTs) and do not give full custody to the third party, you need to use direct wrapping like so:

```
struct ObjectWrapper has key {
    id: UID,
    original_owner: address,
    to_swap: Object,
    fee: Balance<SUI>,
}
```

The `ObjectWrapper` wraps the object to swap `to_swap` and tracks its original owner. You may also need to pay a fee for the swap.

To request a swap, you define an entry function:

```
public entry fun request_swap(object: Object, fee: Coin<SUI>, service_address: address, ctx: &mut TxContext) {
    assert!(coin::value(&fee) >= MIN_FEE, 0);
    let wrapper = ObjectWrapper {
        id: object::new(ctx),
        original_owner: tx_context::sender(ctx),
        to_swap: object,
        fee: coin::into_balance(fee),
    };
    transfer::transfer(wrapper, service_address);
}
```

In this function, the object to be swapped is wrapped using `ObjectWrapper`, and a fee is specified. The wrapper is then sent to a service address.

The crucial thing here is that even though the service operator owns the ObjectWrapper, they can't access or steal the wrapped "Object" inside it. This is because Sui doesn't allow access to the wrapped object without a specific unwrapping function, which is not defined in this module.

### Wrapping through `Option`

In the Direct wrapping example above you had to destroy an object to get the one inside it out. But sometimes, you might want more flexibility, where the wrapping type doesn't always have the wrapped object inside it, and you can replace the wrapped object with a different one when needed.

Let’s take an example of a warrior that has a sword and shield. He should have an option to either have or not have them. He should be able to add a new sword and shield or replace the current ones. 

In the code below, we define a `SimpleWarrior` type with optional `sword` and `shield` fields. The `sword` and `shield` are other Sui object types.

```
struct SimpleWarrior has key {
    id: UID,
    sword: Option<Sword>,
    shield: Option<Shield>,
}

struct Sword has key, store {
    id: UID,
    strength: u8,
}

struct Shield has key, store {
    id: UID,
    armor: u8,
}
```

When you create a new warrior, you start with no equipment:

```
public entry fun create_warrior(ctx: &mut TxContext) {
    let warrior = SimpleWarrior {
        id: object::new(ctx),
        sword: option::none(),
        shield: option::none(),
    };
    transfer::transfer(warrior, tx_context::sender(ctx))
}
```

This function `create_warrior` creates a new `SimpleWarrior` with no sword or shield.

To equip a new sword or shield, you can define functions like below:

```
public entry fun equip_sword(warrior: &mut SimpleWarrior, sword: Sword, ctx: &mut TxContext) {
    if (option::is_some(&warrior.sword)) {
        let old_sword = option::extract(&mut warrior.sword);
        transfer::transfer(old_sword, tx_context::sender(ctx));
    };
    option::fill(&mut warrior.sword, sword);
}
```

In the above function `equip_sword` you pass the warrior as a mutable reference and a sword to wrap into the warrior. If the warrior already has a sword, it first removes the old one and sends it back to the sender. Then, it wraps the new sword into the warrior. This way, the warrior can replace their equipment when they equip something new. 

## Wrapping through `vector`

In Sui, you can wrap objects in a vector field of another Sui object, which is similar to wrapping objects using the `Option` type. This approach allows an object to contain zero, one, or many wrapped objects of the same type.

Let’s consider an example involving pets and a farm:

```
struct Pet has key, store {
    id: UID,
    cuteness: u64,
}

struct Farm has key {
    id: UID,
    pets: vector<Pet>,
}
```

In this code, we have two object types:

1. `Pet`: Represents individual pets and has a unique ID and a "cuteness" value, which is just a placeholder for the pet's characteristics.
2. `Farm`: Represents a farm and has a unique ID as well. The key feature here is the `pets` field, which is a vector of `Pet` objects. This means a farm can contain multiple pets.

With this setup, you can add multiple pets to a farm. Each pet is wrapped in a `Pet` object, and these objects are collected and stored in the `pets` field of the farm object. This allows you to manage and access all the pets associated with a particular farm through the farm object.

## That’s a wrap

In this lesson, you got fully equipped with the object wrapping. You know very well what it is and how you can work with it in Move on Sui. In next lesson, we will move forward with more of advanced topics and learn events in Move on Sui.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/9.%20Advanced%20Concepts%20in%20Move%20on%20Sui/1.%20Object%20Wrapping.md

Object Wrapping

# Events in Move on Sui

Hey learner, I want to give you a bow because trust me if you have meticulously gone through all the lessons till now, you have a good amount of knowledge on how to code using Move on Sui and that’s amazing! Now in this lesson, we learn about some advanced stuff that you can do using Move on Sui so let’s get started.

## Why do you need events in Sui?

Okay, so whenever you interact with a contract on the Sui blockchain, there is a lot of inflow and outflow of data and since Move on Sui is an object-centric language, it's the Sui object that acts as the medium of communication with the Sui blockchain, but what if you want to monitor this inflow and outflow of data? This is where events come in, you can emit events from the smart contracts based on some criteria that need to be met for the smart contract to emit the event.

For example, you have a NFT contract which has read functions like:

- What is the total supply?
- What is the token ID of the NFT?
- Now what if you want to get a notification whenever someone mints an NFT?

To solve this issue you can use events to emit certain parameters like the Token ID of the NFT minted, the Address of the user who brought the NFT, etc. Let me quickly walk you through how to implement events in your Sui smart contract

**Note:** Events on Sui are also represented as Sui objects.

## How can we emit events using Move on Sui?

Before getting started with the code part, let me walk you through the different attributes in the event object in Sui:

- `id`: JSON object containing the transaction digest ID and event sequence.
- `packageId`: The object ID of the package that emits the event.
- `transactionModule`: The module that performs the transaction.
- `sender`: The Sui network address that triggered the event.
- `type`: The type of event being emitted.
- `parsedJson`: JSON object describing the event.
- `timestampMs`: Unix epoch timestamp in milliseconds.

I think that’s enough for the theory part, let’s move on to understand this concept using code snippets

So, to create an event using Move on Sui, the first step would be to import.

```
use sui::event;
```

Let me explain events using codes, first, let’s create our `Hero` object.

```
module example::events {
	use sui::object::{UID};

 //*Object representing our hero*
	Struct Hero has key{
		id: UID,
		power: u8,
		}
}
```

Now let’s create a sword for our hero.

```
module example::events {
	use sui::object::{UID};
 
	//*Object representing our hero*
	Struct Hero has key, store{
		id: UID,
		power: u8,
	}
	 
	//*Object representing our hero's sword*
	Struct Sword has key {
	id: UID
	}

}
```

Now let’s create a fun to buy the sword. Currently, I will not play around with the hero to keep the example simple.

```
module example::events {
	use sui::object::{UID};
	use sui::tx_context::{Self, TxContext};
	use sui::transfer;
 
	//*Object representing our hero*
	Struct Hero has key, store{
		id: UID,
		power: u8,
	}
	 
	//*Object representing our hero's sword*
	Struct Sword has key {
	id: UID
	}

	//function to buy a sword, if the user owns a hero
	pub fun buy_sword (hero: Hero, ctx: &mut TxContext){
		let sword = Sword {
		id: object::new(ctx),
		};
		
	//Transfer the sword to the caller of this function
		transfer::transfer(sword, tx_context::sender(ctx));

	} 

}
```

Now what if I want the smart contract to notify me whenever someone buys a sword? For this purpose, we will use events, let me walk you through them.

```
module example::events {
	use sui::object::{UID};
	use sui::tx_context::{Self, TxContext};
	use sui::transfer;
 
	// Object representing our hero
	struct Hero has key, store{
		id: UID,
		power: u8,
	}
	 
	// Object representing our hero's sword
	struct Sword has key {
		id: UID
	}
	
	// Object representing an event
	struct buySwordEvent has copy, drop {
	  owner: address,
	}

	// Function to buy a sword, if the user owns a hero
	pub fun buy_sword (hero: Hero, ctx: &mut TxContext){
		let sword = Sword {
		id: object::new(ctx),
		};
		
	// Emitting an event with the address of the user who brought the sword
	event::emit(buySwordEvent {
      owner: tx_context::sender(ctx),
   });

	//Transfer the sword to the caller of this function
		transfer::transfer(sword, tx_context::sender(ctx));

	} 

}
```

Now, whenever a sword is brought, an event will be emitted notifying about the successful buying of the sword. 

## That’s wrap

In this lesson, we learned about events on Sui and also understood how to implement events using Move on Sui. Hope this was fun for you, next lesson will be even more exciting for you so stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/9.%20Advanced%20Concepts%20in%20Move%20on%20Sui/2.%20Events%20in%20Move%20on%20Sui.md

Events in Move on Sui

Daniel

Ashik

Advanced Concepts in Move on Sui

Apply everything you've learned in this course and build a calculator from scratch using Move.

# Challenge: Create a Calculator Contract using Move on Sui

Now that you have covered all the basics of Sui Move, it is about time to challenge yourself and do some coding.

So I’ll explain the what are the requirements of the challenge. And you can build it. So why wait, let’s start!

## Build a calculator

So the task is to build a calculator for integers of u64 using the operators, functions, and all Sui Move basics you have learned so far.

- Create a function and object according to your needs.
- Create a function named `add` that takes two input parameters. It adds the value of two integers and returns the results.
- Create a function named `sub` that takes two input parameters. It subtracts the second integer value from the first one and returns the results.
- Create a function named `mul` that takes two input parameters. It multiples both integers and returns the results.
- Create a function named `div` that takes two input parameters. It divides the first integer with the second integer and returns the results.

## Deploy and interact with the calculator contract

- After completing the code of the calculator, deploy it on the Sui blockchain.
- Now go to Sui Explorer and interact with the contract.

## Wrap it up

In conclusion, this lesson allowed you to practically apply your Sui Move and blockchain knowledge by creating and deploying a calculator (+,-,x,%) contract.

In the next lesson, we will focus on learning the solution to this assignment.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/10.%20Challenge/1.%20Challenge%20Create%20a%20Calculator%20Contract%20using%20Move.md

Challenge: Create a Calculator Contract using Move on Sui

# Solution: Create a Calculator Contract using Move on Sui

So I hope you are done with the solution but let’s discuss the solution and deploy it on Sui too.

## Complete code

The complete code for the Calculator is:

```
module calculator::calculator{
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};
    use sui::transfer;

    struct Output has key, store{
        id: UID,
        result: u64,

    }

    public entry fun start (ctx: &mut TxContext){
       let output = Output{
            id: object::new(ctx),
            result: 0,
        }; 

        transfer::public_transfer(output, tx_context::sender(ctx));  

    }

    public entry fun add (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a + b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx));  
    }
    
    public entry fun sub (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a - b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx)); 
    }

    public entry fun mul (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a * b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx));
    }

    public entry fun div (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a / b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx));
    }

}
```

## Explanation

Let’s go through the code:

```
module calculator::calculator{
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};
    use sui::transfer;
```

Importing Modules:

- We begin by importing the necessary modules that provide tools and functionality for our program.
- `use sui::object::{Self, UID};`: This line imports modules related to objects, including the Self and UID types, which help us manage unique identifiers for objects.
- `use sui::tx_context::{Self, TxContext};`: Here, we import modules for transaction context handling, including Self and TxContext types.
- `use sui::transfer;`: This imports the transfer module, which enables us to transfer objects.

```
    struct Output has key, store{
        id: UID,
        result: u64,

    }
```

Defining a Struct:

- We define a struct named `Output` using the `struct` keyword.
- The `struct` has two fields:
    - `id`: It's a unique identifier (UID) for each instance of the `Output` object.
    - `result`: This field stores a 64-bit unsigned integer (u64) that represents the result of calculations.

```
    public entry fun start (ctx: &mut TxContext){
       let output = Output{
            id: object::new(ctx),
            result: 0,
        }; 

        transfer::public_transfer(output, tx_context::sender(ctx));  

    }
```

Defining the `start` function:

- We create a public entry function named `start` that takes a mutable reference to a `TxContext` as an argument.
- Inside the `start` function:
    - We create a new `Output` object named `output using `let output = Output { id: object::new(ctx), result: 0 };`
    - We set the `id` field of the `output` object to a unique identifier generated using `object::new(ctx)`.
    - We initialize the `result` field to 0, as if we're starting with a calculator set to zero.
    - Finally, we use `transfer::public_transfer` to transfer the `output` object to someone, specifying the sender as `tx_context::sender(ctx)`.

```
    public entry fun add (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a + b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx));  
    }
```

Defining the `add` function:

- This is a public entry function called `add`.
- It takes two 64-bit unsigned integers (`a` and `b`) as inputs and a mutable reference to a `TxContext` (`ctx`) to handle the transaction context.
- Purpose: This function is meant to add two numbers and store the result in an `Output` object.

Inside the function:

- `let output = Output { id: object::new(ctx), result: a + b };`
    - We create a new `Output` object named `output`.
    - We assign a unique identifier (UID) to the `output` object using `object::new(ctx)`.
    - We calculate the sum of `a` and `b` and store it in the `result` field of the `output` object.
- `transfer::public_transfer(output, tx_context::sender(ctx));`
    - We transfer the "output" object to someone, specifying the sender as `tx_context::sender(ctx)`.

```
    public entry fun sub (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a - b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx)); 
    }
```

Defining the `sub` function:

- This is a public entry function called `sub`.
- It takes two 64-bit unsigned integers (`a` and `b`) as inputs and a mutable reference to a `TxContext` (`ctx`) to handle the transaction context.
- Purpose: This function is meant to subtract two numbers and store the result in an `Output` object.

Inside the function:

- `let output = Output { id: object::new(ctx), result: a + b };`
    - We create a new `Output` object named `output`.
    - We assign a unique identifier (UID) to the `output` object using `object::new(ctx)`.
    - We calculate the subtraction by subtracting `b` from `a` and storing it in the `result` field of the `output` object.
- Finally, we transfer the `output` object to someone, specifying the sender using `tx_context::sender(ctx)`.

```
    public entry fun mul (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a * b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx));
    }
```

Defining the `mul` function:

- This is the `mul` function, which handles multiplication.
- It takes two 64-bit unsigned integers, `a` and `b`, and the transaction context `ctx`.

Inside the function:

- We create a new `Output` object.
- We calculate the result by multiplying `a` and `b`.
- The `output` object stores this result.
- We transfer the `output` object, specifying the sender using `tx_context::sender(ctx)`.

```
    public entry fun div (a:u64, b:u64, ctx: &mut TxContext){
        let output = Output{
            id: object::new(ctx),
            result: a / b,
        };
        
        transfer::public_transfer(output, tx_context::sender(ctx));
    }
```

Defining the `div` function:

- This function, `div` handles division.
- It takes two 64-bit unsigned integers, `a` and `b`, and the transaction context `ctx`.

Inside the function:

- We create a new `Output` object.
- We calculate the result by dividing `a` by `b`.
- The `output` object stores this result.
- We transfer the `output` object, specifying the sender using `tx_context::sender(ctx)`.

The code defines a calculator program with a struct `Output` to store results and various arithmetic operations (addition, subtraction, multiplication, and division) as public entry functions. Each function creates an `Output` object with the result and transfers it to someone using the `transfer`.

## Deploy the contract

Replace the [YOUR_ADDRESS] in the following command with your account address and run it:

```
sui client switch --address [YOUR_ADDRESS]
```

- Make sure you have enough gas. If you don’t have it, head over to the [Sui Devnet faucet discord channel](https://discord.com/channels/916379725201563759/971488439931392130) and paste “!faucet [YOUR_ADDRESS]” to receive 10 SUI tokens.
    
    

Run the following commands so we can deploy on Sui devnet:

```
sui client switch --env devnet
```

To publish the contract, copy the absolute path of your `Hello.move` file. Replace [YOUR_PATH] with the absolute path of your file and run the following command:

```
sui client publish --gas-budget 10000000 [YOUR_PATH]
```

We will have a long output but scroll to the start of output and copy the Transaction Digest. Head over to [https://suiexplorer.com/?network=devnet](https://suiexplorer.com/?network=devnet). Paste the Transaction Digest in the search bar to find your transaction on the Sui Explorer. 

Now click on the package address of the calculator module:

![Frame 3560370.jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Solution:%20Create%20a%20Calculator%20Contract%20using%20Move%20on%20Sui/Frame_3560370.jpg?raw=true)

You will see all the functions shown below:

![Frame 3560370 (1).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c2/Solution:%20Create%20a%20Calculator%20Contract%20using%20Move%20on%20Sui/Frame_3560370_(1).jpg?raw=true)

Now go ahead and interact with the functions and enjoy~

## That’s a wrap

In this lesson, we learned how to create a Calculator contract using Move. We discussed the code structure and the purpose of each function. We also provided instructions on deploying the contract on Sui Devnet. Feel free to explore and interact with the functions of the contract. Happy coding!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/10.%20Challenge/2.%20Solution%3A%20Create%20a%20Calculator%20Contract%20using%20Move%20on%20Sui.md

Solution: Create a Calculator Contract using Move on Sui

Al Hifzan

ViDA

Ruben

Challenge

Conclude the course and review the key takeaways from your learning journey.

# Wrap Up

Alright, let's wrap it up and celebrate your incredible journey! It's time to take a moment and reflect on everything you've learned in this course. Let's summarize what you've learned and how it can empower you in the world of blockchain development.

## Getting Started

In the beginning, we introduced you to the world of Move on Sui and explained why it was created. You've set up your Sui SDK, created your account, and deployed your first Hello World contract. These initial steps are crucial for laying the foundation of your journey.

## Variables and Constants in Move on Sui

You've gained an understanding of how to declare variables and constants, exploring various data types and operators in Move. This knowledge is essential for building complex smart contracts and applications.

## Functions in Move on Sui

Functions are the heart of any program, and you've learned how to create them with different visibility specifiers. You've also grasped the basics of function design, which is vital for crafting effective and efficient smart contracts.

## Objects in Move on Sui

Objects are fundamental to Sui Move, and you now know how to declare and use them in your contracts. The concept of object composability enables you to create sophisticated and modular applications.

## Control Flow in Move on Sui

Control flow is crucial for managing the logic of your contracts. You've learned how to declare loops and have taken on quick challenges to reinforce your skills.

## Advanced Concepts in Move on Sui

Delving into more advanced topics like event logging and object wrapping, you've gained insights into how to make your contracts more versatile and informative.

## Practice Move on Sui

To put your knowledge to the test, you've faced the challenge of developing a Calculator contract. The solution to this challenge has equipped you with a practical understanding of how to apply your skills in real-world scenarios.

With this course, you've unlocked the potential to build decentralized applications and smart contracts on the Sui blockchain.



## ⚒️ A small yet important request:

This is a 100% open-source project like all the other projects on our platform. You can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects/tree/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications). If you find any issues in the course, please feel free to resolve it. We, at Metaschool, love love love contributions by our community and acknowledge the contributors on our [Discord](https://discord.com/invite/vbVMUwXWgc) and GitHub, too.

While you’re contributing:

1. Don’t forget to star ⭐️ our repository. We will be very thankful! ❤️
2. We are a completely free platform and we aim to stay the same, so please consider following us on [X](https://bit.ly/move-on-sui-twitter) and [LinkedIn](https://bit.ly/move-on-sui-linkedin) as well. 🫶


## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20on%20Move%20on%20Sui%20and%20Explore%20its%20Applications/11.%20Let%E2%80%99s%20Wrap%20It%20Up/1.%20Wrap%20Up.md

Wrap Up

Arataka

NIgga

Let’s Wrap It Up

Setup your wallet to mint your proof of completion NFT

Connect Metamask

Become a part of our vibrant and supportive community!

Join our Discord

Spread the word about what you are building

Follow us on Twitter

Keep us informed of your progress so we can assist you

Submit your first assignment

Reach half course

Complete the course to earn NFT along with XP

Complete Course

Submit your feedback at course completion and help us improve your learning experience