An extensive learning track for developers to get started in Move on Sui and build high quality advanced level dApps.

Master Sui Move, Build Beyond

For every decentralized exchange (DEX) application, a loyalty program is of utmost importance as it makes your DEX dApp stand out by offering unique rewards to users such as NFT awards. In this course, you will learn to create such a loyalty program. You will first start with setting up the development environment. Then will get on building the loyalty contract, deploying the dApp, and integrating the contract with your DEX frontend. Once the program is created, you can interact with it using the DEX frontend. The program will allow you to receive DEX and DEXC balances at each ETH and USDC swap. Then you can stake this balance and get NFT rewards after each fifth swap.

# What Are We Building Today

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

So what are we building today? We will be building a loyalty smart contract using the Sui Move and then deploying it on the Sui blockchain. 

This loyalty smart contract will allow us to implement the loyalty program for our dex dApp. Loyalty programs help differentiate your dex dApp from others by giving unique rewards to the users such as NFTs.

Let’s look at how you will interact with the contract by the end of the course.

![interact-gif-3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/What%20Are%20We%20Building%20Today/interact-gif-3.gif?raw=true)

## Course Overview

We will:

1. Set up Sui Wallet and dev environment (if not already set)
2. Create our loyalty smart contract in Move on Sui
3. Deploy the smart contract on the Sui blockchain

## Who exactly should take this course?

This course is for web3 developers and builders who wish to build on the Sui blockchain and have completed our first three courses on Sui. You should have basic programming knowledge as it will help you have a quick start to this course. 

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

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

1. Build and deploy the loyalty smart contract on Sui
2. Explore opportunities within the Sui ecosystem via SuixMetaschool Discord House
3. Earn up to 1000 XPs
4. 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.

![course-gif](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. Please, do your quick assignments properly. 
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. Stay happy and positive!

Alright guys, no need to wait any longer. See you in the next lesson!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Building%20Today.md

What Are We Building Today

# Introduction to Dex and Loyalty Programs

Hey folks, we’re so glad that you completed the first four courses of this Sui learning path. In this lesson, we will revise what is Dex. We will explore what are loyalty programs and why we have a need to create a loyalty contract for our dex dApp that we created in the last course.

## Let’s revise, what is decentralized exchange (dex)?

A decentralized exchange (often abbreviated as DEX) is a type of cryptocurrency exchange that operates without a central authority or intermediary. Instead of relying on a centralized platform to facilitate trades and hold users' funds, DEXs use smart contracts or other decentralized protocols to enable peer-to-peer trading directly between users.

We all would have used Metamask at a certain point and you would have held some tokens. Now, if you want to swap your token for another token, you will need an exchange who can do that. There are two ways to go about it - Centralized exchange and Decentralized Exchange. 

## What are loyalty programs?

There is a lot of dex present in the blockchain ecosystem. So, why one should use your dex dApp? Here’s where the loyalty program comes in. Let me give you an example, a loyalty program will be very similar to credit card points where you receive certain number of points on certain usage criteria, in our case, we will be giving out 1 DEX coin for every 2 swap and now users can stake the DEX coin on the loyalty dApp and earn 1 point for every swap on the dex dApp. Now users can accumulate these points and claim an NFT on every 5 point

This is what makes a user get incentivised to use your dex dApp and use it as frequently as they can just to get the rewards you will introduce.

## So, what does our loyalty dApp do

The loyalty contract we will implement in this course will reward the user with an NFT. Let me summarise how it will work,

- At each swap, made at dex, the user gets DEX and DEXC balance.
- Using the loyalty program, the user will stake these tokens.
- At the point the user stakes their tokens, the loyalty dApp will start giving them the rewards.
- After 5 rewards, the user will be eligible to collect the reward, i.e., NFT.

## Wrap up

Alright, guys, that's a wrap on dex and loyalty dApp! You recalled what is the dex and how the loyalty programs work.

In the next lesson, you will set up the environment for writing your contract. Don't forget to complete the assignment before moving on!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/1.%20Let%E2%80%99s%20Get%20Started/2.%20Introduction%20to%20Dex%20and%20Loyalty%20Programs.md

Introduction to Dex and Loyalty Programs

# Set Up Environment

Welcome back!  So you completed revising Move on Sui. Well, in this lesson, you're going to learn how to set up the environment for running your code. Ready for another round of exhilarating learning? Let's dive right in!

**Note:** We assume that you have already installed the Sui and Rust in your system in the last course of the Sui course path.

## Update Rust and Sui

Before moving forward, please update Rust and Sui in your system using the following commands.

```
rustup update stable
cargo install --locked --git https://github.com/MystenLabs/sui.git --branch testnet sui
```

## Check your version

Open your favorite terminal. Let’s check your Sui installation version.

```
sui --version
```

**Note:** If you face errors while installing Sui please make sure to follow all the steps in the lesson **Deploy Your First Sui Contract**.

## Create your Sui folder

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 `metaschool`:

```
sui move new loyalty
```

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

- 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 called `loyalty.move`. Here’s what the will look like:

![loyalty-structure.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20Environment/loyalty-structure.png?raw=true)

## Check your wallet

You can view the current active address using the following command:

```
sui client active-address
```

If you do not have an active address, follow the steps given below:

1. 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/sui-loyalty-dapp/Set%20Up%20Environment/deploy-5.png?raw=true)
    
- **Important**: Save the recovery phrase, it is important to have it to import your wallet.
1. Replace `[YOUR_ADDRESS]` in the command below with the address you received after running the last command and run it.
    
    ```
    sui client switch --address [YOUR_ADDRESS]
    ```
    
2. Head over to the [Sui Testnet faucet discord channel](https://discord.com/channels/916379725201563759/1037811694564560966) and paste “!faucet [YOUR_ADDRESS]” to receive 10 SUI tokens.

## Wrap up

In this lesson, you set up your environment. Now, we are ready to write the code of the fungible token.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/2.%20Set%20Up%20Development%20Environment/1.%20Set%20Up%20Environment.md

Set Up Environment

# Writing a Loyalty Smart Contract

Now that you have set up your development environment, let's start writing our smart contract. 

Let’s start writing our code now: 

## Writing the loyalty contract

Navigate to the `sources/loyalty.move`. Let's go through the code line by line that you will be writing:

First, `metaschool` is the package name. It should be the same as the name of the folder we used to initialize the Sui workspace using the command `sui move new metaschool`. So, if you have used any other name, make sure to replace it here. Moreover, `loyalty` is the module name. So, if you have named it something else than `loyalty`, make sure to update it here.

```
module loyalty::loyalty
```

- This line defines a module named `metaschool::loyalty`, which will contain the loyalty contract implementation. A module is a way to organize code and group related functionality together.

```
use sui::clock::Clock;
  use sui::object::{Self, UID};
  use sui::coin::{Self, Coin};
  use sui::tx_context::TxContext;
  use sui::balance::{Self, Balance};

  use deepbook::clob_v2::Pool;
  use deepbook::custodian_v2::AccountCap;
  
  use dex::eth::ETH;
  use dex::usdc::USDC;
  use dex::dex::{Self, DEX, Storage};
```

- Here, we are importing modules that contain pre-built functions and types to be used in the code.

```
struct LoyaltyAccount has key, store {
    id: UID,
    stake: Balance<DEX>,
    points: u64
  }
  
  struct NFT has key, store {
    id: UID
  }
```

- Now we have defined an object with the information about the amount of DEX Coin staked in the program and the amount of points accumulated per swap.

Now let's create a function `create_account` which creates an account object to keep track of a user points and stake amount as follows: 

```
public fun create_account(ctx: &mut TxContext): LoyaltyAccount {
    LoyaltyAccount {
      id: object::new(ctx),
      stake: balance::zero(),
      points: 0
    }
  }
```

- We will be creating another function `loyalty_account_stake` which allows a module to read the amount of DEX coins staked in `LoyaltyAccount`. We will also be creating a function `loyalty_account_points` to read the number of points in a `LoyaltyAccount`.

```
public fun loyalty_account_stake(account: &LoyaltyAccount): u64 {
    balance::value(&account.stake)
  }

  public fun loyalty_account_points(account: &LoyaltyAccount): u64 {
    account.points
  }
```

- Next, we will be creating a function get_reward which mints NFT to the user in return for 5 points. We also need to make sure that after the NFT mint, those 5 points are deducted from users’ accounts.

```
public fun get_reward(account: &mut LoyaltyAccount, ctx: &mut TxContext): NFT {
    assert!(account.points >= 5, ENeeds5Points);

    let points_ref = &mut account.points;
    *points_ref = *points_ref - 5;

    NFT {
      id: object::new(ctx)
    }
  }
```

- Finally, we are creating a function to stake the DEX Coins and earn rewards as below:

```
public fun stake(
    account: &mut LoyaltyAccount,
    stake: Coin<DEX>
  ) {
    balance::join(&mut account.stake, coin::into_balance(stake));
  }

  public fun unstake(
    account: &mut LoyaltyAccount,
    ctx: &mut TxContext
  ): Coin<DEX> {
    let value = loyalty_account_stake(account);

    coin::take(&mut account.stake, value, ctx)
  }

  public fun place_market_order(
    account: &mut LoyaltyAccount,
    self: &mut Storage,
    pool: &mut Pool<ETH, USDC>,
    account_cap: &AccountCap,
    quantity: u64,
    is_bid: bool,
    base_coin: Coin<ETH>,
    quote_coin: Coin<USDC>,
    c: &Clock,
    ctx: &mut TxContext,    
  ): (Coin<ETH>, Coin<USDC>, Coin<DEX>) {
    let (eth, usdc, coin_dex) = dex::place_market_order(self, pool, account_cap, quantity, is_bid, base_coin, quote_coin, c, ctx);

      if (loyalty_account_stake(account) != 0) {
        
          let points_ref = &mut account.points;
          *points_ref = *points_ref + 1;
      };

    (eth, usdc, coin_dex)
  }
```

We have successfully created our loyalty contract. 

## Complete code

The final contract should look like below: 

```
module loyalty::loyalty {
  
  use sui::clock::Clock;
  use sui::object::{Self, UID};
  use sui::coin::{Self, Coin};
  use sui::tx_context::TxContext;
  use sui::balance::{Self, Balance};

  use deepbook::clob_v2::Pool;
  use deepbook::custodian_v2::AccountCap;
  
  use dex::eth::ETH;
  use dex::usdc::USDC;
  use dex::dex::{Self, DEX, Storage};

  const ENeeds5Points: u64 = 0;

  struct LoyaltyAccount has key, store {
    id: UID,
    // Amount of DEX Coin staked in the program
    stake: Balance<DEX>,
    // Amount of points accumulated per swap
    points: u64
  }
  
  struct NFT has key, store {
    id: UID
  }

  // @dev It creates an account object to keep track of a user points and stake amount
  public fun create_account(ctx: &mut TxContext): LoyaltyAccount {
    LoyaltyAccount {
      id: object::new(ctx),
      stake: balance::zero(),
      points: 0
    }
  }

  // @dev It allows a module to read the amount of DEX coins staked in an `LoyaltyAccount`
  public fun loyalty_account_stake(account: &LoyaltyAccount): u64 {
    balance::value(&account.stake)
  }

  // @dev It allows a module to read the number of points in a `LoyaltyAccount`
  public fun loyalty_account_points(account: &LoyaltyAccount): u64 {
    account.points
  }

  // @dev It mints an NFT to the user in exchange for 5 points
  public fun get_reward(account: &mut LoyaltyAccount, ctx: &mut TxContext): NFT {
    // Make sure he has at least 5 points
    assert!(account.points >= 5, ENeeds5Points);

    // Deduct 5 points
    let points_ref = &mut account.points;
    *points_ref = *points_ref - 5;

    // Mint the reward
    NFT {
      id: object::new(ctx)
    }
  }

  public fun stake(
    account: &mut LoyaltyAccount,
    stake: Coin<DEX>
  ) {
    // Deposit the coin in the contract
    balance::join(&mut account.stake, coin::into_balance(stake));
  }

  public fun unstake(
    account: &mut LoyaltyAccount,
    ctx: &mut TxContext
  ): Coin<DEX> {
    // Save the total balance amount in memory
    let value = loyalty_account_stake(account);

    // unstake the balance into a coin
    coin::take(&mut account.stake, value, ctx)
  }

  // @ User can swap via the program to earn points
  public fun place_market_order(
    account: &mut LoyaltyAccount,
    self: &mut Storage,
    pool: &mut Pool<ETH, USDC>,
    account_cap: &AccountCap,
    quantity: u64,
    is_bid: bool,
    base_coin: Coin<ETH>,
    quote_coin: Coin<USDC>,
    c: &Clock,
    ctx: &mut TxContext,    
  ): (Coin<ETH>, Coin<USDC>, Coin<DEX>) {
    let (eth, usdc, coin_dex) = dex::place_market_order(self, pool, account_cap, quantity, is_bid, base_coin, quote_coin, c, ctx);

          // If the user has 0 DEX tokens staked he earns no points
      if (loyalty_account_stake(account) != 0) {
        
          // Borrow mut
          let points_ref = &mut account.points;
          // Increment
          *points_ref = *points_ref + 1;
      };

    (eth, usdc, coin_dex)
  }

  // @dev It allows a test file to destroy the Loyalty Account object
  #[test_only]
  public fun destroy_account_for_testing(account: LoyaltyAccount) {
    // @dev Properties without the drop ability must be destroyed via their libraries
    let LoyaltyAccount { id, stake, points: _ } = account;
    balance::destroy_for_testing(stake);
    object::delete(id);
  }

  // @dev It allows a test file to destroy the NFT object
  #[test_only]
  public fun destroy_nft_for_testing(nft: NFT) {
    let NFT { id} = nft;
    object::delete(id);
  }
}
```

## Wrap up

Congratulations on completing your loyalty contract. It only gets more interesting from here! Next, we will be deploying our contract. See you in the next section.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/3.%20Build%20Your%20Loyalty%20DApp/1.%20Writing%20a%20Loyalty%20Smart%20Contract.md

Writing a Loyalty Smart Contract

# Deploying the Loyalty DApp

Great job on writing your loyalty smart contract in the last section. In this section, let's deploy our contract. 

## Update `loyalty` contract `Move.toml` file

To successfully deploy your Dex Sui project, it is necessary to update the `Move.toml` file. This update is required to ensure that certain dependencies can be easily installed and used. During the implementation of the contracts, you may have noticed the use of some libraries. To install and use these libraries, please update the `Move.toml` file with the following information.

**Note:** Remember to use the same package name as you used while creating the Move on Sui project.

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

[dependencies]
MoveStdlib = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "testnet-v1.18.0" }
Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet-v1.18.0" }
Dex = { local = "../dex/contracts" }
DeepBook = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/deepbook", rev = "testnet-v1.18.0" }

[addresses]
loyalty = "0x0"
std = "0x1"
sui = "0x2"
deepbook = "0xdee9"
dex = "0xa1dce324bcf781692a358adb27bd105844231d35863b5c99f94e54801d653788"
```

Here, we use our Dex dApp and provide the local Dex app path. Therefore, you must have developed the Dex dApp in the last course of this Sui learning path. Please provide the local Dex dApp path here. Ensure that the Dex is deployed beforehand to use it in the loyalty app (if you have 100 Sui testnet tokens, or else you can use our contract). In our case, the path looked like the following.

```
Dex = { local = "/Users/username/Desktop/metaschool/Sui/dex-app/dex" }
```

At `[addresses]`, you must have noticed that we are using the dex contract address.  Use this address and don’t change it because this contract already has a pool created which costs 100 SUI tokens that you need to run the dex and loyalty dApp. If you have an a dex contract with the pool created, feel free to use it here.

Using the existing contract address will help loyalty dApp not publish the dex contract again but use the existing published address.

**Note:** Please use the updated versions of the packages and the same version as used in the dex dApp. Otherwise, loyalty dApp will give an error.

## Update `dex` contract `Move.toml` file

As you have noticed we are adding a local dex dApp path to our loyalty dApp, we need to update the dex `Move.toml` file to add the appropriate published address of the dex dApp. Otherwise, your loyalty will give you an error. Please use the following `Move.toml` file.

```
[package]
name = "Dex"
version = "0.0.1"
published-at = "0xa1dce324bcf781692a358adb27bd105844231d35863b5c99f94e54801d653788"

[dependencies]
MoveStdlib = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "testnet-v1.18.0" }
Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet-v1.18.0" }
DeepBook = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/deepbook", rev = "testnet-v1.18.0" }

[addresses]
dex = "0xa1dce324bcf781692a358adb27bd105844231d35863b5c99f94e54801d653788"
std = "0x1"
sui = "0x2"
deepbook = "0xdee9"
```

We added the `published-at` address under the `[package]` field and a `dex` address under the `[addresses]` field. 

## **Build and publish loyalty dApp on Sui**

Follow the following steps to build and publish your Sui project on the blockchain.

### Step 1

Firstly, we must enter our `loyalty` directory since it contains our contracts.

```
cd loyalty
```

### Step 2

Now, let’s build our move file using the following command. This will create a new `build` folder and a `Move.toml` file. 

```
sui move build
```

Here’s what the output will look like.

![output-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Deploying%20the%20Loyalty%20DApp/output-1.png?raw=true)

### Step 3

You now need to set up a development environment in Sui to deploy on the Sui testnet using the following commands: 

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

### Step 4

Run the following command to publish the Move project to the testnet finally:

```
sui client publish --skip-dependency-verification --gas-budget 90000000
```

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

![output-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Deploying%20the%20Loyalty%20DApp/output-2.png?raw=true)

- **Note**: If you encounter an “Insufficient funds” error then you can head over to the [Sui Testnet faucet discord channel](https://discord.com/channels/916379725201563759/1037811694564560966) and paste “!faucet [YOUR_ADDRESS]” to receive 10 SUI tokens.
    
    

### Step 5

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

![output-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Deploying%20the%20Loyalty%20DApp/output-3.png?raw=true)

## Wrap up

In this lesson, you deployed a loyalty smart contract on the Sui blockchain. Good luck with your future deployments!

Next, let’s integrate the contract with frontend.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/4.%20Deploy%20the%20DApp/1.%20Deploying%20the%20Loyalty%20DApp.md

Deploying the Loyalty DApp

# Set Up the Frontend

Kudos! We have deployed our dApp. We are all set to proceed in setting up our front end. No more waiting, let’s go!

## Setting up the loyalty frontend

Open a new terminal in your `loyalty` directory or continue using the previous terminal if opened.

Run the following command to clone the frontend directory:

```
git clone https://github.com/0xmetaschool/sui-loyalty-dapp-frontend.git
```

The front end will have the following file structure.

![frontend-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-1.png?raw=true)

Let’s install our dependencies:

```
yarn install
```

## Find the loyalty package ID

Next, we need to find the package ID of our `loyalty` module, that we implemented while writing the contracts. Follow the following steps to do so.

1. Head over to the [Sui Explorer](https://suiexplorer.com/?network=testnet) and enter the Transaction Digest that you got in the last lesson in the search bar.
    
    ![frontend-1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-1.gif?raw=true)
    

2. You can see the sidebar with the “Summary” heading. Please scroll to the end of the sidebar to find the “Publish” field.
    
    ![frontend-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-2.png?raw=true)
    

3. Now, open the “Object” field by clicking on the “>” sign in the “Publish” field and click on the “loyalty” module.
    
    ![frontend-gif-1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-gif-1.gif?raw=true)
    

You will see the page something like this:

![frontend-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-3.png?raw=true)

1. Copy your package ID, as mentioned in the following screenshot. This will be your loyalty package ID that we will use in our front end.
    
    ![frontend-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-4.png?raw=true)
    

## Set up the environment variables

Why do we even need a loyalty package ID? We need the ID to connect our Move project with the front end. Remember we discussed in the last lesson that to run the loyalty app we need a pool. So, head over to the `.env` file in your cloned front end, and fill in with your loyalty package ID.

```
LOYALTY_PACKAGE_ID=YOUR_LOYALTY_PACKAGE_ID
```

Also, we need the same environment variables we used for our dex app. As the loyalty app won’t work until you don’t sign in using Google, swap some ETH tokens to USDC tokens and USDC tokens to ETH tokens. So, either use the same `.env` file data here or copy-paste the following variables. We have also filled these variables in the `.env` file for your ease.

```
DEX_STORAGE_ID=0x6912d83e2c4868386511fe3f6f18aff9399b9ad5cae2d97943766e2ff160ab25
DEX_PACKAGE_ID=0xa1dce324bcf781692a358adb27bd105844231d35863b5c99f94e54801d653788
NEXT_PUBLIC_CLIENT_ID_GOOGLE=YOUR_GOOGLE_CLIENT_ID
URL_ZK_PROVER=http://175.41.177.22:8001/v1
```

Do replace `YOUR_GOOGLE_CLIENT_ID` with your Google client ID because it cannot be used by multiple users.

## Run the frontend

To run the frontend, run the following command in your terminal.

```
yarn dev
```

The command will give you an output like this:

![frontend-6.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-6.png?raw=true)

Head over to the link, the `local` field is showing to you. You will see something like this in your browser.

![frontend-5.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Set%20Up%20the%20Frontend/frontend-5.png?raw=true)

## That’s a wrap

Phew, we’re so proud of you for setting up the front end yourself. Next, we will interact with the front end and see how does our dex and loyalty dApps work together.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/5.%20Work%20With%20the%20Frontend/1.%20Set%20Up%20the%20Frontend.md

Set Up the Frontend

# Interact With the Frontend

You have successfully set up everything for your front end. It's time to interact with dex and loyalty dApp simultaneously and see how it works.

## Interact with the frontend

Let's run our app by entering the following command in your terminal, located in the frontend directory, now that all credentials have been set up.

```
yarn dev
```

This time try again to log in by clicking on the “Sign with Google” button. Verify your Google account and then log in. After logging in wait for a few seconds for ZK to get connected with your app. After the request is completed, you will see a page like this.

![interact-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Interact%20With%20the%20Frontend/interact-1.png?raw=true)

Initially, you’ll see 0 balance in all or a few fields if you haven’t interacted with your dex dApp before. To use the loyalty dApp we must fill in the “DEX Swaps” and “DEXC Balance” fields. To fill these fields, we need to swap some tokens interchangeably.

Let’s play around with different features of our application and see how it works.

1. First, click on the “Mint SUI” button to increase your SUI balance.
2. To fill your USDC and ETH balance, click on the “Mint ETH” and “Mint USDC” buttons separately.
3. Before swapping, it is necessary to increase balances because, without any ETH or USDC, you will not be able to swap the tokens.
4. To swap the tokens, fill in the balance and click on the “Swap” button.
5. If you want to swap ETH to USDC or USDC to ETH tokens, click on the arrow button to switch their places.

### Swap ETH to USDC tokens

Here’s how we’re swapping the ETH tokens to USDC tokens.

![interact-gif-1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Interact%20With%20the%20Frontend/interact-gif-1.gif?raw=true)

### Swap USDC to ETH tokens

Here’s how we’re swapping the USDC tokens to ETH tokens.

![interact-gif-2.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Interact%20With%20the%20Frontend/interact-gif-2.gif?raw=true)

After swapping the tokens, you’ll see the changes in the balance fields like the following.

![interact-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Interact%20With%20the%20Frontend/interact-2.png?raw=true)

## Head over to loyalty dApp

It is time to stake your DEXC tokens to earn rewards for using the Dex app. When you stake the DEXC tokens one time, you will start earning the reward for every 2nd token swap. When you collect 5 rewards, you will become eligible for a reward.

Head over to loyalty dApp by clicking on the Loyalty dApp button on the left top corner and stake or unstake your DEXC tokens.

![interact-gif-3.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/What%20Are%20We%20Building%20Today/interact-gif-3.gif?raw=true)

After 5 rewards, you will be eligible to collect the reward. Let's see how it works. In our case, the reward will be an NFT.

![interact-gif-4.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/sui-loyalty-dapp/Interact%20With%20the%20Frontend/interact-gif-4.gif?raw=true)

## That’s a wrap

We’re so proud of you for completing the course and setting up your own on chain loyalty application. In the next lesson, we will wrap up the course and overview what you have learned so far.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/5.%20Work%20With%20the%20Frontend/2.%20Interact%20With%20the%20Frontend.md

Interact With the Frontend

# Let’s Wrap It Up

Congratulations! Throughout this learning journey, you've gained valuable insights into the Sui network, mastered the Move programming language, and successfully crafted and deployed a smart contract for a loyalty dApp. 

Let's reflect on your achievements and outline the key takeaways.

## Key Learnings:

1. **Sui Ecosystem Exploration:**
    - You've familiarized yourself with the Sui network, understanding its capabilities and how it stands out in the blockchain space.
2. **Move Advance Concepts:**
    - You implemented the Move project from start to end and implemented all of the advanced concepts you studied in the second course of this Sui Learning Path.
3. **Development Environment Setup:**
    - Set up the Sui toolchain and ensure your development environment is ready for creating decentralized applications.
4. **Smart Contract Development:**
    - Progressed through the step-by-step process of coding a smart contract for a loyalty dApp. From data structure setup to deployment, you've seen how Move empowers developers in the Sui ecosystem.
5. **Frontend Integration:**
    - Created a front end for your dApp, showcasing the seamless interaction between smart contracts and user interfaces.
6. **Interaction:**
    - Learned how to interact with your dApp, ensuring that it performs as expected.

## 🛠 Contribute to this project!

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

Here’s the GREAT news for you! This is an open-source project, you can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects). If you find any issues in the course, please feel free to resolve them.

We, at Metaschool, love love love contributions by our community and we give acknowledgment to contributors in our discord and GitHub profile too. Also, don’t forget to star ⭐️ our repository! we will be very thankful! ♥️

## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20a%20Loyalty%20Contract%20with%20Move%20on%20Sui/6.%20Wrap%20Up%20the%20Course/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Let’s Wrap It Up

Build a Loyalty Contract with Move on Sui

Sui is a modern blockchain with exceptional performance that utilizes the Move on Sui programming language for smart contracts and dApps that are both secure and efficient. This course helps you explore Sui, learn about its working, features, what differentiates it from other blockchains, and understand why Sui is one of the top choices for Web3 developers.

# What Are We Learning Today?

Gm everyone ☀, today we are very excited to bring the first-ever detailed course about Sui blockchain for developers on Metaschool.

So, what are we learning? We will be developing an understanding of the Sui blockchain and how it works. This course is very important as it will help you with the necessary basic knowledge to kick off your exciting journey towards building on Sui. While starting with theories and concepts can feel slow, learning about Sui from this angle is not only important but also interesting, as Sui introduces a new development paradigm for blockchains. So let’s start with the basics!

Now, what is Sui? Sui is a layer-1 blockchain featuring an innovative object-oriented data model that is asset-centric and developer-friendly, allowing for a familiar yet powerful developer experience. Sui employs the Move programming language for the development of smart contracts. Move was purpose-built for the secure management of blockchain assets.

There are 300+ projects built on Sui including top-tier games and DeFi projects, such as Arcade Champion, Ethos 8192, VMeta, Cetus, Scallop, Turbos, and more.

## Course overview

Before we get started with the content, let me give you an overview of what we will be covering:

1. Introduction to Sui blockchain
2. Learn what can be built on Sui
3. Understand Sui’s architecture
4. Explore Sui key features

## Who exactly should take this course?

This course is for beginner web3 developers who wish to learn about Sui blockchain. Don’t worry if you are not experienced with Move on Sui, we’ve got your back. Anyways it's good to have a basic knowledge of coding.

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

As a developer, you can expect the following outcomes by completing this course:

1. Understand the unique aspects of Sui
2. Learn value propositions of building on Sui
3. Explore opportunities within the Sui ecosystem via the SuixMetaschool Discord House
4. Earn up to 1000 XPs

## Proof of completion

Well, glad to spill the beans here. After you complete this course with me, you will get XPs and a special NFT, which will unlock many more opportunities on the Metaschool platform. Here is a sneak peek of what the NFT will look like below.

![img-1](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/everything-about-sui-course-twitter) and [LinkedIn](https://bit.ly/everything-about-sui-course-linkedin), it would be a great support.  🫣
4. Stay happy and positive!

Alright guys, no need to wait any longer, let's dive right into our awesome Sui Blockchain course! Let's do this! 🙌


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Learning%20Today.md

What Are We Learning Today?

# What is Sui and How Does it Redefine the Possibilities in Web3

Hey all, as I mentioned earlier, we will be starting with the concepts needed to build the best apps in Sui. I will do my best to help you all understand these key concepts before we dive into building some awesome projects on Sui. Grab your favorite drink and let’s get started!

## What is Sui?

Sui is a layer-1 blockchain, meaning that it is entirely self-reliant, handling its own consensus, execution, and security. Sui’s network architecture allows it to finalize transactions at lightning-fast speeds with consistent, predictable costs - essential elements for application builders. We won’t go too deep into the details of the network design, but the high-level, need-to-know info is this: Sui uses delegated proof-of-stake for Sybil resistance along with novel consensus and ordering mechanisms – Narwhal & Bullshark, respectively. Paired with an object-centric design, these elements of Sui’s network architecture allow for the benefits in speed and cost useful to both developers and end-users. This makes Sui ideal for latency-sensitive applications, such as gaming and fast retail payments.

**Quick Note:** "Latency-sensitive" means things that can't wait or need to happen really quickly. If you're playing a video game and you press a button to jump, you expect the game to respond instantly. In a world of fast internet and instant messages, we all like things to happen without any waiting, and that's being "latency-sensitive.”

Sui departs from the all-to-common (and sometimes problematic) Solidity and Ethereum Virtual Machine (EVM) combo, opting for the Move programming language and the corresponding Move VM. The Move programming language was actually developed by the Facebook Libra/Diem team. The individual leading the development of the Move language, Sam Blackshear, actually is a co-founder of Mysten Labs, the R&D company supporting and developing Sui technology. At a high level Move was developed to create a more secure, asset-centric programming language purpose-built for blockchain use. We will dig more into the nitty gritty details later but for now, that's a good baseline to start learning more about Sui.

![img-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c1/What%20is%20Sui%20and%20How%20Does%20it%20Redefines%20the%20Possibilities%20in%20Web3/image.jpeg?raw=true)

Here are a few points which summarize everything we have talked about earlier:

- Sui has novel consensus and ordering mechanisms – Narwhal and Bullshark.
- The object-centric data model of Sui is the bedrock for a unique and powerful developer experience.
- The Move programming language is used to write smart contracts in Sui.

## History of Sui

After a number of testnet iterations in 2022, Sui’s mainnet was launched on May 3, 2023.

You may remember the Libra/Diem project that Meta (fka Facebook) was built around 2020. If not, here's a quick primer: Libra/Diem was Meta’s blockchain that they built in-house with the aim to provide users with an extremely fast payment method with all the benefits of a blockchain optimized for payments. One hugely important thing that came out of this project was the development of a new programming language, Move. For better or for worse, Meta faced strong regulatory headwinds and decided to discontinue the project. Well, five leaders from the Libra/Diem project were determined to continue their work by extending the possibilities of what they had created at Meta and left Meta to create a new company Mysten Labs.

Led by five visionaries from the Libra/Diem project–Evan Cheng, Adeniyi Abiodun, Sam Blackshear, George Danezis, and Kostas Chalkias–Mysten Labs built Sui. As mainnet launch neared, the Sui Foundation was created with the goal of supporting Sui adoption and helping foster a thriving community around Sui.

After a number of testnet iterations in 2022, Sui’s mainnet was launched in May 2023. Since then, advancements of the chain have continued to be shipped by Mysten Labs along with a community of builders developing applications running on Sui.

## How is Sui different?

We learned a lot about what Sui exactly is, right? Now, what makes it different? Let’s see what problems Sui solves and what differentiates it from other blockchains

1. **Reliable Availability, Consistent Costs, and Easy Onboarding to support Mass Adoption**
    1. **Problem**: Broader blockchain usage has been limited as there are a number of friction points that hinder adoption by the masses. Networks have downtime, fees are often unpredictable, and onboarding new users to web3 is hard. Existing blockchains are all grappling with these issues, unfortunately, often in retrospect after a problem is observed. An effective developer platform cannot be chasing its tail addressing these issues, solutions need to be preplanned as much as possible.
    2. **Solution**: Sui has been built from the ground up with learning and observations from other blockchain ecosystems. Sui’s network architecture has been designed to be resilient in times of intense demand, the fee structure is designed to remain consistent for users to avoid unexpected changes, and the development team behind Sui has shipped tools for devs to address common challenges when building for the masses.
        
        Sui is building for the needs of the future with a fresh approach. When building a powerful application, you want to make sure that the underlying technology will support not only your current needs but also your future needs. By building a highly performant layer-1 with a fresh perspective, Sui offers a compelling developer environment for the next generation of blockchain apps.
        
2. **True Asset Ownership**
    1. **Problem:** It is often thought that anything on a blockchain associated with a self-custodial account is unilaterally owned by the account operator. This is actually not the case. For example, in Ethereum, any asset minted via a smart contract (i.e. ERC-20 tokens) never actually ‘leaves’ the smart contract. The user does not truly *own* the asset, they are just assigned rights to interact with it. While this might seem like an unimportant detail it actually has impacts on the user, which we will discuss when we dive deeper into objects and ownership in Sui..
    2. **Solution:** Now this problem can’t be solved by any blockchain because most of the L1s and L2s out there share a similar architecture like Ethereum. But in the case of Sui, assets like tokens are represented as individual "objects" with ownership defined directly on the object, not just as entries in a smart contract. This means each asset (e.g., a token or an NFT) lives independently from the originating smart contract. Users have direct control over objects and do not need to place trust in the smart contracts ownership mapping.

## That’s a wrap

In conclusion, we have learned the basics of Sui, its origin story, and how it differentiates itself from other blockchains. If what you’ve learned here sounds intriguing, don’t worry, we’ve just begun to scratch the surface. After we learn more about what makes Sui tick, we will begin creating some really cool things. So, stay excited!

In the upcoming lessons, we will learn how Sui made it possible to be secure and scalable. Stay tuned!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/1.%20Let%E2%80%99s%20Get%20Started/2.%20What%20is%20Sui%20and%20How%20Does%20it%20Redefines%20the%20Possibilities%20in%20Web3.md

What is Sui and How Does it Redefine the Possibilities in Web3

# Dope Stuff on Sui

I’m so proud of you all for learning all about Sui, taking a step ahead, and coming this far in the course. In this lesson, we will explore the following:

1. What developers are building on Sui
2. What dApps have been deployed on Sui
3. Why you should ship cool stuff on Sui

Let’s get started!

## What exactly can you build on Sui?

As a developer, you can build some dope stuff on Sui.

![img-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c1/Dope%20Stuff%20on%20Sui/image.png?raw=true)

Let’s look at what exactly you can build and ship on the Sui blockchain in detail.

1. **Commerce:** Sui’s architecture and design allow for lightning-fast transactions that can even skip the time-consuming consensus steps. This is super useful for applications in the realm of commerce, as nobody wants to wait for consensus on their cup of coffee.
2. **DeFi:** Developers wanting to build DeFi applications in Sui have many unique tools at their fingertips – programmable transaction blocks, sponsored transactions, deep book, etc. – all with the speed, cost-efficiency, and throughput that Sui offers.
3. **Games:** As mentioned before, games are latency-sensitive and Sui can support extremely low-latency transactions that can be processed in parallel. Not only this, but Sui’s architecture is built to handle massive throughput demands - something extremely important to a highly played-game.

## Cool stuff built on Sui

Now, let’s look at some amazing stuff that has already been built and is in the process of being built on the Sui.

- **Games**: Let’s look at some gaming studios that are partnering with Sui to launch their games on the Sui blockchain.
    - Arcade Champions
    - [PanzerDogs](https://play.panzerdogs.io/)
    - [Worlds Beyond](https://worldsbeyondnft.com/)
    - Run Legends by [Talofa Games](https://www.talofagames.com/)
    - Cosmocadia by [Lucky Kat](https://www.lucky-kat.com/)
- **DApps**: Now, let’s explore some of the DApps built on Sui.
    - [SuiNS](https://suins.io/): Naming service dApp
    - [Typus](https://typus.finance/): DeFi Protocol
    - [Suia](https://suia.io/): Social dApp
    - [Cetus](https://www.cetus.zone/): DeFi
    - [Clutchy](https://clutchy.io/marketplace): NFT Marketplace
    - [SuiScan](https://suiscan.xyz/mainnet/home): Sui Block Explorer

## Why should you ship cool stuff on Sui?

Since you've already understood how Sui is an excellent blockchain for building various things on-chain, it's high time you took a deeper dive into the Sui blockchain’s ecosystem.

Anyone can build high-quality dApps on Sui that are otherwise very challenging to build on alternative platforms.

If you decide to build your own product on Sui, you can submit a grant proposal to receive financial and technical support from the Sui Foundation. Even if you don’t submit a grant application, the teams at Mysten Labs, the Sui Foundation, and the Sui community are available to assist with any questions you might have!  You can join the Sui Discord community using this [link](https://discord.com/invite/sui).

**Fun Fact:** Sui offers various grants, including developer grants, education grants, and academic research grants. The developer grant program offers a range of $10,000 to $100,000 for qualified on-chain developers. You can find more details about it here: [Sui Grants Hub](https://sui.io/grants-hub).

**Don’t worry!** We will discuss how Sui works in detail in the upcoming lesson.

## That’s a wrap

Great job on learning all about the amazing things Sui is doing for developers like you! Are you excited to dive more into the Sui blockchain? Now in the next section, we explore how Sui works in detail.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/1.%20Let%E2%80%99s%20Get%20Started/3.%20Dope%20Stuff%20on%20Sui.md

Dope Stuff on Sui

# Sui vs Ethereum

Welcome back, learners! In the last section, we gained a basic understanding and an overview of the Sui blockchain. In this section, we will understand how the Sui blockchain actually works. But before getting straight into it, let’s first understand how certain implementations in Sui are different from other traditional blockchains like Ethereum.

## Sui vs Ethereum

Let me give you a bird’s eye view of how fast the Sui chain is.

![img-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c1/Sui%20vs%20Ethereum/image.png?raw=true)

So what can we conclude from this? Let me walk you through each point one by one with real-world examples to make it easier for you to understand.

## Transaction processing speed

Sui has much higher scalability than other mainstream blockchains like Ethereum and Solana. Sui is capable of handling a maximum Transactions Per Second (TPS) of 297,000, based on testnet stress tests. Why is this important? Well, if you’ve been around for a while you’ve seen what happens with limited transaction throughput on Ethereum – network fees increase dramatically as everyone is outbidding each other to try and push their transaction through.

Eg: Imagine you are in a restaurant where there is only one cook, it basically means the time taken for cooking will be longer. The cooking time of food can be slow and especially during high traffic times, there might be a huge waiting time. And hence, they would be delivering far fewer orders per unit of time. This is how legacy blockchains like Ethereum work.

Now imagine each individual’s order is assigned to different cooks who work independently of each other. This would speed up the order processing time substantially and hence deliver many more orders per unit of time. This is one reason why TPS is higher in Sui, validators can take care of different transactions than each other. Sui’s architecture is built for even greater TPS, a future upgrade will allow validators to add additional worker machines to quickly meet a surge in demand. This is like having extra off-duty chefs you can call on in case you need them.

## Move language

As I mentioned earlier Sui uses an object-centric smart contract language called Move which is a more expressive language which means it provides a flexible and detailed way to define how assets and smart contracts interact with each other which results in fewer security pitfalls, well-defined object ownership and less room for mistakes in your code.

This is a very crucial feature as web3 has witnessed several attacks due to such vulnerabilities. If I have to take an example I would go for the famous [DAO hack](https://www.coindesk.com/consensus-magazine/2023/05/09/coindesk-turns-10-how-the-dao-hack-changed-ethereum-and-crypto/) which resulted in $60m of stolen ETH and resulted in Ethereum being divided into two chains - Ethereum and Ethereum classic which recognizes the original Ethereum blockchain.

Move on Sui is already pre-built to prevent such vulnerabilities like reentrancy attacks, underflow, overflow, etc. Well, we will be discussing a lot about Move in the next course. Let’s now move on to the execution part!

## Execution model

Sui’s execution model helps it to process multiple transactions at any given time exactly like a multi-lane highway. We will understand how it achieves this using parallel transactions in more detail in the next section. But let’s get a basic overview here with our restaurant example.

To understand this, let's revisit the restaurant example we used while explaining the TPS concept:

- In a restaurant with only one cook (like Ethereum), customers arrive at a leisurely pace, with enough time between orders for the cook to handle each one. Even though it might take a bit longer to prepare each order, it doesn't significantly affect business because of the low traffic. But as the traffic goes high, the queue builds up and it gets hard for the restaurant to process the orders.
- Sui, on the other hand, operates like a restaurant with multiple cooks. Even if orders arrive with some overlap, each cook can prepare orders independently, without waiting for the previous one to finish. This parallel processing is what sets Sui apart and allows it to achieve a high TPS.

## That’s a wrap

In a nutshell, Ethereum and Sui are both Layer 1 blockchains, but they have distinct smart contract languages, transaction speeds, and execution styles. Sui's parallel execution makes it a top choice for high-throughput and scalable applications. We are sure, you might already be wondering how they are able to do this, and we won’t keep your curiosity on hold anymore! Let’s get right into it in the next section.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/2.%20Let%E2%80%99s%20Dig%20Deep%20into%20Sui%20Architecture/1.%20Sui%20vs%20Ethereum.md

Sui vs Ethereum

# How Does Sui Even Work?

Now that you have gone through how Sui differs from Ethereum blockchain, let’s understand the basic architecture of Sui Blockchain and get to know how Sui manages to achieve such a high performance.

## How does Sui work?

Several factors play a crucial role in shaping the foundation of Sui and determining how it operates. Let's delve into what these factors are.

1. Objects in Sui
2. Object Ownership
3. Transaction Cycle

Let’s explore them in detail now.

### Objects in Sui (Move architecture)

Now that we have understood the significance of using Move, we need to understand the most fundamental component of Sui, objects.

**What are the objects?**

Objects are like structs in any other programming language. Each object can store any type of data whether an integer, boolean, or address. Consider objects like a box that stores different items of different sizes. Now each of these boxes has an owner, right? Each Move object has an ‘owner’ defined directly on the object itself. This means that the object entirely encompasses ownership information, with no need for ownership mapping to be paired with the asset as we see in other blockchains. There is more to object ownership, so let’s dig deep!

**Different types of objects**

In Sui, the two most common ownership types are single owner objects and shared objects.

- **Single owner objects:** In a single owner object, only a single address has the ability to transfer or use the object. Okay, but why does this matter? Single owner objects on Sui can bypass the lengthy consensus process and be finalized in less than a second! Now that we have gone through the technical explanation let me take through this concept using a real-world example.
    
    Picture this: a high-security, personal vault in a prestigious bank. This vault is exclusively yours, accessible only through a biometric system that recognizes your fingerprint. Inside, you store your most precious valuables — jewelry, important documents, and maybe even a rare collection of coins. Much like a single-owner object on Sui, this vault is under your sole control. You decide when to access it, and what to store or remove, without any need for consensus. Your actions with the vault are immediate and autonomous, mirroring the efficiency and security of single-owner objects in the digital realm of blockchain.
    
![img-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c1/How%20Does%20Sui%20Even%20Work%3F/image.png?raw=true)
    
- **Shared objects:** Shared objects have no single owner but are either open for all users to interact with or a defined subset. Let’s take an example to understand this.
    
    Now, imagine a shared family heirloom, say, an exquisite antique clock, held in a family estate. This clock is a shared object, much like shared objects on Sui. Every family member has the right to access, use, or even temporarily remove the clock for special occasions. However, significant decisions, like selling or altering the clock, require a family consensus, and actions are taken only after collective agreement. This shared stewardship reflects the shared objects in blockchain, where multiple parties have access and a degree of control, but major changes necessitate mutual consent. It's about balancing individual desires with the responsibilities and privileges of shared ownership.
    

### Asset Ownership

Blockchains are cool as they give you the power to own and manage your digital assets, like NFTs (unique digital items), without any middleman. Let's explore how asset ownership differs on Sui.

**Ownership on Other Blockchains (e.g., Ethereum):**

Imagine Ethereum as a secure digital vault for your NFTs. These NFTs are kept inside something called a "smart contract," a bit like an automated vault. In Ethereum, an account is the basic unit of storage – there are the typical accounts that you think of (owned by a human) and those that house smart contracts. The NFTs you “own” are actually held within the smart contract account that they originate from.

Now, the contract developer can set the rules for this contract, just like specifying how your vault should work, but here's the catch: As an NFT holder, you don't directly control the NFTs inside it. To do anything with your NFTs, like lending or trading them, you need to engage with the smart contract and assume that the contract has granted you ownership rights to the NFT. Think of the smart contract as an intermediary, it helps you, but it can also make things a bit more complicated.

For instance, let's say you want to lend one of your NFTs to a friend. You can't just hand it over as you would a physical item. You need to use the smart contract to facilitate this process. This is the same for any other token on Ethereum as all tokens are deployed via smart contracts, even stablecoins.

**Ownership on Sui:**

Now, Sui takes a different approach. It's like having your personal art gallery at home. Remember that everything on Sui is an object with a defined owner, this means that the user actually has direct ownership rights to the object – no need to trust the smart contract the object originated from. These objects represent your NFTs, and the cool part is that they're stored directly in your personal account, just like your art hanging on the wall in your own secured home. You have direct control.

This direct ownership means you can easily lend your NFT to a friend or trade it with another user without dealing with a smart contract as an intermediary. Sui simplifies the process, putting asset ownership right in your hands. Since objects, like NFTs, often have just a single owner, we can leverage the benefits of owned object transactions, which is lightning-fast speed.

Now explore how transactions work a bit more to understand how owned object transactions can be completed so fast.

### Transactions in Sui

Sui processes the owned object transactions and shared object transactions in different ways.

**Owned Object Transactions**

For owned object transactions, like transferring a token, Sui does not require the network to reach a consensus before finalizing the transaction. This is because ownership of the object is defined directly in the object itself; so long as the defined owner is the one initiating the transaction, the transaction will be executed without waiting for consensus. Instead of relying on the typical consensus-related protocols for gossiping the transaction around the network, Sui uses a Byzantine Consistent Broadcast (BCB) protocol for owned object transactions. Unlike the traditional way of requiring validators to reach a consensus on the transaction validity, owned object transactions are able to be finalized without consensus, making them super quick.

Let me summarize the whole process for you,

- The sender submits a transaction to the network.
- Sui validators vote if the transaction falls in line with its requirements through a proof-of-stake mechanism.
- The sender collects the votes, creating an unsigned certificate that acts as proof of Byzantine Fault Tolerance.
- The sender shares this certificate with the network and all validator nodes verify its validity.
- For owned object transactions if the certificate is valid, the transaction is then finalized and executed.
- The user is returned the signed certificate which signifies transaction finality.

Owned object transactions also do not need to be sequenced before finalization, this means that unrelated transactions can be executed in parallel. For instance, think about Anna sending 1 NFT to Suzan and Ray sending 10 tokens to Tom. These transactions have nothing to do with each other. With Sui, they can be processed simultaneously and quickly, without the need for everyone to agree on the order.

**Shared Object Transactions**

Transactions involving shared objects, such as a DEX smart contract, require sequencing and consensus as multiple users could be attempting to interact with the same object at once. Thus, there must be some sense of transaction order. While shared object transactions must go through consensus, Sui’s novel consensus mechanism is still able to finalize transactions quickly. In Sui, there are two separate protocols for sequencing and consensus, which are called Narwhal and Bullshark, respectively.

The process is very similar to that of an owned object transaction, aside from the addition of sequencing and consensus before finalization. Let me summarize the process for you:

- The sender sends the transaction to the network.
- Sui validators vote if the transaction falls in line with its requirements through a proof-of-stake mechanism
- The sender collects the votes, creating an unsigned certificate that acts as proof of Byzantine Fault Tolerance
- The sender shares this unsigned certificate with the network.
- Sui validators then come to a consensus on the sequence and validity of the transaction output using Narwhal and Bullshark.
- The user is returned the signed certificate which signifies transaction finality.

In short, the process is pretty similar to that of owned object transactions until the signing of certificates. Shared object transactions require Sui validators to reach a consensus on the ordering and outcome of the transaction before signing the certificate.

For our family heirloom example, imagine one family member wants to sell an antique, but the other family members must agree before that action can happen.

## That’s a wrap

Congrats! While we are still working through the theory, know that it is extremely important to help you when making design decisions for your own applications. Next, we will learn a bit more by going through the features of the Sui blockchain. See you in the next section!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/2.%20Let%E2%80%99s%20Dig%20Deep%20into%20Sui%20Architecture/2.%20How%20Does%20Sui%20Even%20Work.md

How Does Sui Even Work?

# Let’s Recall Sui's Key Features

Great job on learning how Sui works in detail! I am sure that if your friends ask you about Sui you can easily answer now. Bear with me for the next 30 minutes, let me summarize what we have learned so far by going through the key features of Sui. We need to recall what’s so unique about Sui and how it differs from other blockchains. So, let’s recall that.

## Key features of Sui

Let’s discuss some of the key features of the Sui blockchain.

1. **Storing data in objects opens new possibilities:** Sui blockchain stores data in objects rather than storing it in the form of accounts. To recall, objects are like boxes that store different items of different sizes and each box will have a unique ID. Object helps developers to define, create, and manage the data with ease.
2. **Hassle-free sponsored transactions:** In Sui, one address can pay the transaction fees for the transaction that was made by another address. Especially if you're new to this, understanding gas fees and dealing with the transaction process can be a bit confusing. This helps the application builders to pay the initial gas fees for its users and makes the onboarding process so much easier for them. These types of transactions are called Sui-sponsored transactions.
3. **Consistent Network Fees:** Fluctuating fee structures are not intuitive to users. Imagine buying a coffee in the morning, then going to buy one in the afternoon and seeing that the fee is nearly as much as the coffee itself. Sui’s fee structure is designed to remain stable in dollar amounts and does not fluctuate throughout a 24-hour period.
4. **Develop in a Secure Environment:** Sui’s implementation of the Move programming language along with its object-centric design makes for a powerful and extremely secure developer environment. Not only is formal verification by the Move Prover required for applications to deploy, but there are many common smart contract bugs that are not even possible on Sui!
5. **Run transactions in parallel:** Sui’s unique data model allows for parallel transaction execution creating much faster time to finality for many transactions and allowing for the network infrastructure to remain resilient in times of high demand. This is super helpful when you want to solve a web2 problem using Sui as most of the web2 applications need to have fast processing systems.
    
![img-1](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assets_for_sui_c1/Let%E2%80%99s%20Recall%20Sui%20Key%20Features/image.png?raw=true)
    

These are not all the cool features Sui is offering, but for now, these are enough for you to know. Now, let’s explore more about how Sui differs from other blockchains.

## Sui vs other blockchains

Following are some of the unique features that make Sui stand out from other blockchains.

1. **High performance:** Sui offers great performance compared to other blockchains. Its feature to execute parallel transactions makes it much more robust than other blockchains.
2. **Security:** Sui's unique architecture offers great security even under bad circumstances. It smoothly handles the situation where validators get attached or deadlocks happen in the system. Sui offers great assurance to its users that their data will remain secure even if the network gets attacked, which other blockchains can hardly offer. Not only this, the Sui ecosystem constantly monitors the security threats to its community, and identified threats are immediately investigated and fixed to ensure user safety. Different organizations and people have done multiple security audits on different Sui features to ensure great security, for example, security audits on Sui core and Sui’s smart contracts conducted by Halborn. You can find more information on this on [Sui’s official website](https://sui.io/security).
3. **Easier developer experience:** Sui allows developers to create great, secure, reliable NFTs and dApps using Move programming language and object-centric approach.

## That’s a wrap

As we’ve explored Sui, you’ve probably realized that they have taken a fresh approach to many elements of blockchain tech. Whether it’s the data model, native onboarding tools, or tokenomics Sui has approached each with fresh eyes making for an exciting ecosystem. Remember, the community is here to help - Metaschool, the Sui community, the Sui Foundation. If you are interested in going deeper into any aspect, just reach out and start chatting!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/2.%20Let%E2%80%99s%20Dig%20Deep%20into%20Sui%20Architecture/3.%20Let%E2%80%99s%20Recall%20Sui%20Key%20Features.md

Let’s Recall Sui's Key Features

# Let’s Wrap Up the Course

Alright, let's wrap it up and celebrate your incredible journey! 🎉 It's time to take a moment and reflect on everything you've learned in this course. I am super excited for all of you since you all have decided to start with Sui and here we are completing our very first course together.

## Understanding of Sui blockchain

You gained a basic knowledge of the Sui blockchain. You understood what consensus mechanism it uses, what problems Sui solves, and the history of Sui in detail. Let us recall what we learned about Sui.

Sui is a permissionless Layer-1 blockchain. Unlike existing Layer-1 blockchains like Ethereum and Bitcoin, Sui offers lightning-fast transactions with predictable fees and complete ownership of one’s dynamic digital assets.

## Dope stuff on Sui

You explored what developers are building on Sui blockchain, what applications are already built on Sui, and what you can also build. You explored how Sui developers can be supported by grants by delving into the world of Sui blockchain.

## Understanding of Sui Architecture

You gained in-depth knowledge of how Sui works, what consensus it uses and what are the fundamental properties of Sui.


## ⚒️ 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/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols). 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/everything-about-sui-course-twitter) and [LinkedIn](https://bit.ly/everything-about-sui-course-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/Learn%20Everything%20About%20Sui%2C%20its%20Concepts%20and%20Protocols/3.%20Let%E2%80%99s%20Wrap%20It%20Up/1.%20Let%E2%80%99s%20Wrap%20the%20Course.md

Let’s Wrap Up the Course

Learn Everything About Sui, its Concepts and Protocols

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.

# 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.webpf?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

# 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.webp?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

# 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.webp?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.webp?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.webp?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.webp?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.webp?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.webp?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.webp?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.webp?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.webp?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.webp?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).webp?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).webp?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).webp?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).webp?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).webp?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.webp?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).webp?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

# 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

# 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

# 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?

# 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

# 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

# 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

# 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

# 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.webp?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).webp?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

# 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

Build on Move on Sui and Explore its Applications

Hailed as Solana-killer, the Sui blockchain is expected to be the next big thing. It allows you to write impeccable smart contracts with ease, create your very own tokens - all under a secure, immutable umbrella. To sweeten the deal, it is supported by Move, a secure and modular smart contract programming language. If you want to learn building on a powerhouse blockchain paired with an impressive language, Sui and Move are the answers.

# What Are We Building Today

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

So what are we building today? We will be building our very own token in the Move on Sui and then deploying it on the Sui blockchain. This project is important as it equips you with the necessary knowledge to build on Sui.

Let’s look at how you will be interacting with the token by the end of the course. You will mint your token and view it in your wallet. How exciting!!

![newly_minted_token_in_wallet.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_sui_c3/L1_What%20Are%20We%20Building%20Today/sui-explorer-gif.gif?raw=true)

## Course Overview

We will:

1. Set up Sui Wallet and dev environment (if not already set)
2. Create our own token smart contract in Move on Sui
3. Deploy the smart contract on the Sui blockchain

## Who exactly should take this course?

This course is for web3 developers and builders who wish to build on the Sui blockchain and have completed our first two courses on Sui. You should have basic programming knowledge as it will help you have a quick start to this course. 

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

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

1. Build and deploy the token smart contract on Sui
2. Explore opportunities within the Sui ecosystem via SuixMetaschool Discord House
3. Earn up to 1000 XPs
4. 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.

![Untitled](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/fung-sui-twitter) and [LinkedIn](https://bit.ly/fung-sui-linkedin), it would be a great support.  🫣
4. Stay happy and positive!


Alright guys, no need to wait any longer. See you in the next lesson!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/1.%20What%20Are%20We%20Building%20Today.md

# Into the World of Move on Sui

Hey folks, we’re so glad for you to complete the first two courses of this Sui learning path. In this lesson, we will revise a little bit of both, Sui and Move. We know you want to get into coding right away, but revising some of the concepts will help you work on code with ease.

## Let’s revise, the importance of objects in Sui

Objects are like structs in any other programming language. Each object can store any data whether an integer, boolean, or address. They play a huge part in storing a large amount of data in an efficient way. Each object has ownership that identifies who owns the object. Ownership tells us how the transactions will take place for objects. In Sui, there are two types of objects:

1. Single owner object
2. Shared owner object

Here’s how you define an object in Move on Sui.

```
struct ExampleObject has key {
		 id: UID,
		 data_1: u8,
		 data_2: u8,
}
```

**Note:** The object definition does not define the ownership of the object. We define it in the initialization and transferring ownership process. 

## Let’s recall, how to write a contract in Move on Sui

We covered Move contract writing in detail in the previous course. Let's recap with the "Hello World" example 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
/// 
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));
    }

}
```

Let's take a moment to review what was accomplished in this contract. We will summarize the key points for clarity.

**module Definition**

You define the contract using the `module` keyword. Here’s how you are defining it in the above program.

```
module hello_world::hello_world
```

**Import libraries**

Right after defining the module, we import the important libraries we need to mint the contract in Move on Sui just like we are doing in the `hello_world` contract.

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

**Define an object**

Without an object, a contract in Sui is incomplete. It defines the object with the `key` ability and an `id` in Sui. Other abilities come along to make the object work better. Here’s how we’re defining it in the `hello_world` contract.

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

**Define an `entry` function**

It is important to define a function with an `entry` keyword if you want to mint the object and transfer it to the owner. Here’s what the mint function looks like in the `hello_world` contract. 

```
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));
}
```

The `mint` function here, calls the `transfer::public_transfer()` method and minted the `HelloWorldObject` to the Sui global storage.

## Wrap up

Alright, guys, that's a wrap on Sui and Move! You recalled how you could define the simple contract in Move on Sui. While writing the token contract, you will replicate your knowledge and create your own token in Move on Sui.

In the next lesson, you will set up the environment for writing your own contract. Don't forget to complete the assignment before moving on!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool/1.%20Let%E2%80%99s%20Get%20Started/Into%20the%20World%20of%20Move%20on%20Sui.md

Into the World of Move on Sui

# Set Up Environment

Welcome back!  So you completed revising Move on Sui. Well, in this lesson, you're going to learn how to set up the environment for running your code. Ready for another round of exhilarating learning? Let's dive right in!

**Note:** We assume that you have already installed the Sui and Rust in your system in the last course of the Sui course path.

## Check your version

Open your favorite terminal. Let’s check your Sui installation version.

```
sui --version
```

**Note:** If you face errors while installing Sui please make sure to follow all the steps in the lesson **Deploy Your First Sui Contract**.

## Create your Sui folder

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 `metaschool`:

```
sui move new metaschool
```

Navigate to the `sources/` directory. Create a new Move file. I am naming it `pepe.move`. You can name the Move file with whatever coin name you want it to be. It could be Mango, Luffy, or even Pikachu. 😃

This is what my directory looks like now:

![Frame 3560370 (13).jpg](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_sui_c3/L2_Set%20Up%20Environment/Frame_3560370_(13).jpg?raw=true)

## Check your wallet

You can view the current active address using the following command:

```
sui client active-address
```

If you do not have an active address, follow the steps given below:

1. 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/assests_for_sui_c3/L2_Set%20Up%20Environment/deploy-5.png?raw=true)
    
- **Important**: Save the recovery phrase, it is important to have it to import your wallet.
1. Replace `[YOUR_ADDRESS]` in the command below with the address you received after running the last command and run it.
    
    ```
    sui client switch --address [YOUR_ADDRESS]
    ```
    
2. 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.

## Wrap up

In this lesson, you set up your environment. Now, we are ready to write the code of the fungible token.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool/2.%20Setting%20up%20the%20Development%20Environment/Set%20Up%20Environment.md

# Write Your Token Smart Contract in Move

Welcome back!  So you completed setting up your environment. You did awesome! Well, get ready because, in this lesson, you're going to learn how to write your token.  Are you excited? Let's get started!

## Write code

Navigate to the `sources/pepe.move`. Let's go through the code line by line that you will be writing:

First, `metaschool` is the package name. It should be the same as the name of the folder we used to initialize the Sui workspace using the command `sui move new metaschool`. So, if you have used any other name, make sure to replace it here. Moreover, `pepe` is the module name. So, if you have named it something else than the `pepe`, make sure to update it here.

```
module metaschool::pepe {
```

- This line defines a module named `metaschool::pepe`, which will contain the Move token implementation. A module is a way to organize code and group related functionality together.

```
    use std::option;
    use sui::coin;
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};
```

- Import modules (`std::option`, `sui::coin`, `sui::transfer`, and `sui::tx_context`) that contain pre-built functions and types to be used in the code.

```
    struct PEPE has drop {}
```

- Define a new struct called `PEPE` with `has drop` attribute.

```
    fun init(witness: PEPE, ctx: &mut TxContext) {
        let (treasury, metadata) = coin::create_currency(witness, 9, b"PE", b"PEPE", b"", option::some(url::new_unsafe_from_bytes(b"https://silver-blushing-woodpecker-143.mypinata.cloud/ipfs/Qmed2qynTAszs9SiZZpf58QeXcNcYgPnu6XzkD4oeLacU4")), ctx);
        transfer::public_freeze_object(metadata);
        transfer::public_transfer(treasury, tx_context::sender(ctx))
    }

```

- Define a function called `init`, which is the module initializer.
- The `init` function takes the following:
    - Move utilizes a witness design pattern that states that a type passed can only be initiated once. The witness resource needs to be consumed or discarded right away to prevent creating multiple instances of the given object.
    - The one-time witness (OTW) is a special type in Move on Sui that always has one instance. It is used wherever we want certain actions to happen once. For example, creating a coin one time. You can explore more about OTW here: [https://docs.sui.io/concepts/sui-move-concepts/one-time-witness](https://docs.sui.io/concepts/sui-move-concepts/one-time-witness)
    - So we passed the `PEPE` struct that has drop functionality.
    - We also passed a mutable reference to `TxContext`.
- Inside the function, call the `coin::create_currency` function to create a new PEPE currency:
    - Pass the `PEPE` witness as the first argument.
    - The desired decimal places as the second parameter. For example, for 9 as a decimal value; suppose we want to mint 100 tokens, so we need to pass 100*10^9.
    - The symbol of our token is `PE`.
    - The token name is `PEPE` which is the fourth argument.
    - Next, an empty icon URL is added, and an optional metadata too.
- The `coin::create_currency` function returns a tuple containing `treasury` and `metadata` that are `TreasuryCap` and `CoinMetadata` objects respectively.
    - The `TreasuryCap` [i](https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-two/lessons/6_capability_design_pattern.md)s like a manager that controls access to the `mint` and `burn` methods.
- Call `transfer::public_freeze_object` to freeze the metadata so that no one can change the coin metadata once it's published
- Finally, transfer the `treasury` to the sender of the transaction using `transfer::public_transfer`.

```
    public entry fun mint(
        treasury: &mut coin::TreasuryCap<PEPE>, amount: u64, recipient: address, ctx: &mut TxContext
    ) {
        coin::mint_and_transfer(treasury, amount, recipient, ctx)
    }
}

```

- Define a public entry function called `mint`.
- The `mint` function takes a mutable reference to `coin::TreasuryCap<PEPE>`, an `amount` of type `u64`, a `recipient` of type `address`, and a mutable reference to `TxContext` as arguments.
- Inside the function, call the `coin::mint_and_transfer` function to mint new tokens and transfer them to the specified `recipient`.

## Complete code

The complete code for this is below, you can paste it into the file created in Move Studio.

```
module metaschool::pepe{
    use std::option;
    use sui::coin;
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};
    use sui::url::{Self, Url};

    // Name matches the module name but in UPPERCASE
    public struct PEPE has drop {}

    // Module initializer is called once on module publish.
    // A treasury cap is sent to the publisher, who then controls minting and burning.
    fun init(witness: PEPE, ctx: &mut TxContext) {
        let (treasury, metadata) = coin::create_currency(witness, 9, b"PE", b"PEPE", b"", option::some(url::new_unsafe_from_bytes(b"https://silver-blushing-woodpecker-143.mypinata.cloud/ipfs/Qmed2qynTAszs9SiZZpf58QeXcNcYgPnu6XzkD4oeLacU4")), ctx);
        transfer::public_freeze_object(metadata);
        transfer::public_transfer(treasury, tx_context::sender(ctx))
    }

    public entry fun mint(
        treasury: &mut coin::TreasuryCap<PEPE>, amount: u64, recipient: address, ctx: &mut TxContext
    ) {
        coin::mint_and_transfer(treasury, amount, recipient, ctx)
    }
}
```

## Wrap up

Phew! Great work on understanding and creating your first token on Move on Sui. You can explore creating a coin in Sui here: [https://github.com/MystenLabs/sui/blob/main/crates/sui-framework/docs/sui-framework/coin.md](https://github.com/MystenLabs/sui/blob/main/crates/sui-framework/docs/sui-framework/coin.md)

In the next lesson, you will finally deploy the token on the Sui blockchain.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool/3.%20Write%20Your%20Token%20Smart%20Contract%20in%20Move/1.%20Write%20Your%20Token%20Smart%20Contract%20in%20Move.md

Write Your Token Smart Contract in Move

# Deploy Your First Fungible Token on Sui

Welcome back! So you have completed writing your fungible token. You did great! In this lesson, you will dive into deploying your token to the Sui blockchain. Are you excited? Let's get started!

## Code

Here’s the complete code of the contract we wrote in the previous lesson, in case you missed it:

```
module metaschool::pepe {
    use std::option;
    use sui::coin;
    use sui::transfer;
    use sui::tx_context::{Self, TxContext};

    // Name matches the module name, but in UPPERCASE
    struct PEPE has drop {}

    // Module initializer is called once on module publish.
    // A treasury cap is sent to the publisher, who then controls minting and burning.
    fun init(witness: PEPE, ctx: &mut TxContext) {
        let (treasury, metadata) = coin::create_currency(witness, 9, b"PE", b"PEPE", b"", option::none(), ctx);
        transfer::public_freeze_object(metadata);
        transfer::public_transfer(treasury, tx_context::sender(ctx))
    }

    public entry fun mint(
        treasury: &mut coin::TreasuryCap<PEPE>, amount: u64, recipient: address, ctx: &mut TxContext
    ) {
        coin::mint_and_transfer(treasury, amount, recipient, ctx)
    }
}
```

## Deploy your contract

### Step 1

Firstly, we must go into our `metaschool` directory since it contains our contracts.

```
cd metaschool
```

### Step 2

Now, let’s build our move file using the following command. This will create a new `build` folder and a `Move.toml` file. 

```
sui move build
```

### Step 3

You now need to set up a dev environment in Sui to deploy on the Sui testnet using the following commands: 

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

### Step 4

Now is the time to publicize your contract. To do so, copy the absolute path of `pepe.move` by right-clicking on it and then selecting the `copy path` option on VS code. Once you have your path, you can now use the following command to publish by replacing `[YOUR_PATH]` with the path you just copied: 

Note: If you are using IDE other than VS code please try finding the exact complete path for `pepe.move` file.

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

### Step 5

Now that you have published the contract, you will get a long output. Scroll and copy the transaction digest. You can use this transaction digest to search for your transaction using Sui Explorer using the following link: 

[https://suiexplorer.com/?network=devnet](https://suiexplorer.com/?network=devnet)

![sui-explorer-gif.gif](https://github.com/0xmetaschool/Learning-Projects/blob/main/assests_for_all/assests_for_sui_c3/sui-explorer-gif.gif?raw=true)

## Wrap up

In this lesson, you deployed a fungible token on the Sui blockchain. Good luck with your future deployments!

Next, let’s wrap up the course.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool/4.%20Deploy%20Your%20First%20Fungible%20Token%20on%20Sui/1.%20Deploy%20Your%20First%20Fungible%20Token%20on%20Sui.md

Deploy Your First Fungible Token on Sui

# Let’s Wrap It Up

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

## Sui Blockchain and Move on Sui Revision

You have revised the understanding of Sui Blockchain and Move on Sui. You understood what benefits these hold and how we can get benefit from them.

## Writing and Deploying a Smart Contract

You have gained the knowledge to write and deploy your own simple smart contract on the Sui using Move on Sui.

## A Solid Foundation in Smart Contract Development

By understanding the basics of the Sui and Move on Sui, you have a solid foundation to continue exploring and developing 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/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool). 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/fung-sui-twitter) and [LinkedIn](https://bit.ly/fung-sui-linkedin) as well. 🫶



## 🎊 Congratulations

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

WAGMI! Peace out! ✌🏻🔮

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Create%20a%20Fungible%20Token%20with%20Sui%20Move%20%7C%20Metaschool/Let%E2%80%99s%20Wrap%20It%20Up/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Create a Fungible Token with Sui Move

In this course, you’ll learn how to create your own decentralized exchange application using Move on Sui, the native language of the Sui blockchain. You will begin with setting up the development environment. You will then move to building the DEX from scratch. The app will allow you to swap ETH and USDC tokens with each other. After building the DEX, you will deploy the dApp on Sui testnet. Lastly, you will integrate the frontend, run it, and interact with the dApp.

# What Are We Building Today

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

So, what are we building today? We will be building a Token Swap Defi application using Move on Sui, which will help users implement the swap feature in a dex. This dApp will help you swap the Ethereum tokens with the USDC tokens. This project will help you learn to build the end-to-end defi application using Move on Sui.

Let’s look at what your Dex dApp will look like.

![frontend-interact-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/1.%20Getting%20Started/assets/frontend-interact-1.png?raw=true)

## Course Overview

We will:

1. Set up Sui wallet and dev environment (if not already set)
2. Set up the Move project
3. Write different smart contracts in Move on Sui
4. Build the Swap dApp from start to finish
5. Write the test for the Move smart contracts
6. Deploy the dApp on the Sui blockchain
7. Connect the dApp with the frontend
8. Run and interact with the frontend

## Who exactly should take this course?

This course is for web3 developers and builders who wish to build on the Sui blockchain and have completed our first three courses on Sui. You should have basic programming knowledge as it will help you have a quick start to this course. 

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

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

1. Build and deploy the token smart contract on Sui
2. Explore opportunities within the Sui ecosystem via SuixMetaschool Discord House
3. Earn up to 1000 XPs
4. 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 that will unlock many more opportunities for you on the Metaschool platform. Here is what the NFT looks like.

![Untitled](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. Please, do your quick assignments properly. 
2. Join [our discord server](https://discord.gg/vbVMUwXWgc) and ask all relevant questions there.
3. Stay happy and positive!

Alright guys, no need to wait any longer. See you in the next lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/1.%20Getting%20Started/1.%20What%20Are%20We%20Building%20Today.md

# Introduction to DeFi and Dex

We’re so proud of you for deciding to take this course. You have now completed three courses in the Sui learning path and this is going to be your fourth course. 🎊 You are now equipped with all the basic knowledge of the Sui blockchain. In this lesson, we will explore what DeFi is, how Sui helps build DeFi applications, and what features our DeFi application will have.

## Introducing DeFi applications

So, imagine if your money didn't need traditional banks or financial big-shots. That's what DeFi does. Instead of relying on the usual suspects, it lets regular folks like you and me do financial stuff directly with each other. There are no middlemen, just peer-to-peer power.

### How does DeFi work?

Here's the scoop on how DeFi works:

1. DeFi operates on blockchain technology, ensuring secure and immutable transactions through digital blocks.
2. DeFi bypasses traditional intermediaries like banks, offering lower fees and higher interest rates by facilitating direct peer-to-peer transactions.
3. User-friendly applications facilitate DeFi activities such as lending, borrowing, and trading, making financial interactions accessible to all.
4. Leveraging blockchain, DeFi transcends geographical barriers, allowing seamless financial interactions worldwide.

### **Goals of DeFi**

- **Accessibility:** Anyone with an internet connection can interact with a DeFi protocol.
- **Security and Transparency:** Everything's on the blockchain, so it's super secure, and transactions are open for all to see without revealing who you are.
- **Autonomy:** DeFi doesn't need big banks. It's like the rebel leader of finance, doing its thing without the need for central control.

Remember, while DeFi doesn't give you complete anonymity, it's all about changing the financial game for the better.

## DeFi on Sui

Let’s discuss what role Sui plays in DeFi applications and why they are reliable platforms for DeFi creation. 

- Leverages a novel consensus mechanism for efficient and stable transactions, catering to simple and complex DeFi operations.
- Implements parallel execution to execute transactions simultaneously, eliminating delays and ensuring smooth DeFi interactions.
- Introduces storage fund tokenomics, revolutionizing blockchain storage costs and maintaining fair fees, thus creating a well-organized digital ecosystem for DeFi

## What is a decentralized exchange?

A decentralized exchange (often abbreviated as DEX) is a type of cryptocurrency exchange that operates without a central authority or intermediary. Instead of relying on a centralized platform to facilitate trades and hold users' funds, DEXs use smart contracts or other decentralized protocols to enable peer-to-peer trading directly between users.

We all would have used Metamask at a certain point and you would have held some tokens. Now, if you want to swap your token for another token, you will need an exchange who can do that. There are two ways to go about it - Centralized exchange and Decentralized Exchange. 

A traditional or centralized exchange is like a bank: it holds your tokens and manages the trades. But just as a bank can be a target for thieves, centralized exchanges can be vulnerable to hacks or misuse. But with decentralized exchange, you can swap your tokens without any centralized entity but the set of rules governed by smart contracts. 

## Advantages of decentralized exchanges

1. **Security**: Users retain control of their private keys and funds, reducing the risk of centralized exchange hacks or thefts.
2. **Privacy**: Users can trade directly with one another without the need for intermediaries.
3. **Censorship Resistance**: Decentralized exchanges are generally more censorship-resistant since they don't rely on centralized servers or authorities.
4. **Interoperability**: Some decentralized exchanges can facilitate trading between different blockchain platforms or assets.

## That’s a wrap

In a nutshell, Move and Sui Move create the ultimate DeFi HQ. Move's asset-friendly design meets Sui's scalability and low-cost storage, offering a sweet spot for real-time, low-latency trading in the DeFi realm. Next, we will start building and setting up our development environment.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/1.%20Getting%20Started/2.%20Introduction%20to%20DeFi%20and%20Dex.md

Introduction to DeFi and Dex

# Set Up Environment

Welcome back! In this lesson, you'll learn how to set up the environment and the Move project for running your code.

**Note:** We assume that you have already installed the Sui and Rust in your system in the first course of the Sui course path. If not, you can go to this [link](https://metaschool.so/courses/build-on-move-on-sui-and-explore-its-applications/lesson/aa506de1-411f-4675-b9bb-36c746ee31ee) and install it. 

## Check your version

Open your favorite terminal. Let’s check your Sui installation version.

```
sui --version
```

**Note:** If you face errors while installing Sui please make sure to follow all the steps in the lesson [Deploy Your First Sui Contract.](https://metaschool.so/courses/build-on-move-on-sui-and-explore-its-applications/lesson/1f15e1bb-7023-4487-ab7d-21233318af91)

## Set up the Move project

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 as `dex`:

```
sui move new dex
```

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

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

Time to create files for coding, so follow the steps given below:

- Now create 3 new files in the `sources` folder named:
    - `eth.move`
    - `usdc.move`
    - `dex.move`
    
    We will be writing our code in these files.
    
- Next, create a `test` folder in `sources` and create a file named `test_dex.move` inside it.

This is how your project structure will look like:

![Screen Shot 2024-01-29 at 4.26.19 PM.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/2.%20Setting%20Up%20the%20Development%20Environment/assets/Screen_Shot_2024-01-29_at_4.26.19_PM.png?raw=true)

## Check your wallet

You can view the current active address using the following command:

```
sui client active-address
```

If you do not have an active address, follow the steps given below:

1. 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/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/2.%20Setting%20Up%20the%20Development%20Environment/assets/deploy-5.png?raw=true)
    
- **Important**: Save the recovery phrase, it is important to have it to import your wallet.
1. Replace `[YOUR_ADDRESS]` in the command below with the address you received after running the last command and run it.
    
    ```
    sui client switch --address [YOUR_ADDRESS]
    ```
    
2. Head over to the [Sui Testnet faucet discord channel](https://discord.com/channels/916379725201563759/1037811694564560966) and paste “!faucet [YOUR_ADDRESS]” to receive 10 SUI tokens.

## Wrap up

In this lesson, we learned how to set up our project for writing code in Move on Sui. By following the provided steps, we are now ready to start writing code for our Move project. Happy coding!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/2.%20Setting%20Up%20the%20Development%20Environment/1.%20Set%20Up%20Environment.md

# Writing the Ethereum Smart Contract

Welcome back! You are all set to start building the dApp. So why wait, let’s dive right into the coding.

## Ethereum smart contract

Navigate to `sources/eth.move`.

The first task is to create a currency for our faucet I am naming it `ETH`, you can name it however you like.

```
use std::option;
use sui::url;
use sui::transfer;
use sui::coin;
use sui::tx_context::{Self, TxContext};

struct ETH has drop {}
```

- The code starts by importing necessary library (`std::option`, `sui::url`, `sui::transfer`, `sui::coin`, `sui::tx_context::{Self, TxContext}`).
- Next, a struct named `ETH` is defined with drop functionality. This struct will be used as a witness for certain operations.

```
fun init(witness: ETH, ctx: &mut TxContext) {
  let (treasury_cap, metadata) = coin::create_currency<ETH>(
    witness,
    9,
    b"ETH",
    b"ETH Coin",
    b"Ethereum Native Coin",
    option::some(url::new_unsafe_from_bytes(b"https://s2.coinmarketcap.com/static/img/coins/64x64/1027.png")),
    ctx
  );

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

  transfer::public_share_object(metadata);
}

```

- The module initialization function (`init`) is defined, which takes a witness of type `ETH` and a mutable reference to `TxContext`.
- Inside the `init` function:
    - `coin::create_currency` is called to create a new currency (ETH Coin) with specific parameters such as witness, decimal places, symbol, name, icon URL, and optional metadata.
    - The treasury capability and metadata obtained from `create_currency` are then used to transfer the treasury capability to the deployer (`transfer::public_transfer`) and share the metadata publicly (`transfer::public_share_object`).

```
#[test_only]
public fun init_for_testing(ctx: &mut TxContext) {
	  init(ETH {}, ctx);
}
```

- Finally, test functions are defined. In this case, there's a test-only initialization function (`init_for_testing`) annotated with `#[test_only]`. This function calls the main initialization function (`init`) with a dummy `ETH` witness for testing purposes.

## Complete code

The complete code for `eth.move`  is:

```
module dex::eth {
  use std::option;

  use sui::url;
  use sui::transfer;
  use sui::coin;
  use sui::tx_context::{Self, TxContext};

  struct ETH has drop {}

  fun init(witness: ETH, ctx: &mut TxContext) {
      let (treasury_cap, metadata) = coin::create_currency<ETH>(
            witness, 
            9, 
            b"ETH",
            b"ETH Coin", 
            b"Ethereum Native Coin", 
            option::some(url::new_unsafe_from_bytes(b"https://s2.coinmarketcap.com/static/img/coins/64x64/1027.png")), 
            ctx
        );

      transfer::public_transfer(treasury_cap, tx_context::sender(ctx));
      transfer::public_share_object(metadata);
  }

  #[test_only]
  public fun init_for_testing(ctx: &mut TxContext) {
    init(ETH {}, ctx);
  }
}
```

## Wrap up

In this lesson, we coded for creating a new currency. In the next lesson, we will be writing the contracts for USDC. Let’s go!

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/3.%20Build%20Your%20Swap%20DApp/1.%20Writing%20the%20Ethereum%20Smart%20Contract.md

Writing the Ethereum Smart Contract

# Writing the USDC Smart Contract

Welcome back again! Let’s get started right away to create our USDC smart contract. 

## USDC smart contract

Firstly, navigate to `sources/usdc.move` and start writing the following code:

First of all, we start with defining our contract and importing the essential packages that we will use in our code.

```
module dex::usdc {
  use std::option;

  use sui::url;
  use sui::transfer;
  use sui::coin;
  use sui::tx_context::{Self, TxContext};
```

Next, we will define the struct named `USDC`. It is a one-time witness to create a Current. It has the drop ability so it cannot be transferred or stored.

```jsx
struct USDC has drop {}
```

Then, we create an `init` function that runs once on module creation and accepts a one-time `witness` as the first argument. 

We have created a `witness` struct with 1 ability, `drop`, it guarantees that there is only one in the entire network as you can only get it in the `init` function.

Inside the `init` function, we call the `create_currency`. Creating a currency requires a one-time `witness` to ensure it is a unique coin and only the holder of the `TreasuryCap` is allowed to mint and burn this coin.

```jsx
fun init(witness: USDC, ctx: &mut TxContext) {
      let (treasury_cap, metadata) = coin::create_currency<USDC>(
            witness, // One time witness
            9, // Decimals of the coin
            b"USDC", // Symbol of the coin
            b"USDC Coin", // Name of the coin
            b"A stable coin issued by Circle", // Description of the coin
            option::some(url::new_unsafe_from_bytes(b"https://s3.coinmarketcap.com/static-gravity/image/5a8229787b5e4c809b5914eef709b59a.png")), // An image of the Coin
            ctx
        );

      // We send the treasury capability to the deployer
      transfer::public_transfer(treasury_cap, tx_context::sender(ctx));
      // Objects defined in different modules need to use the public_ transfer functions
      transfer::public_share_object(metadata);
  }
```

Lastly, we are adding the test that we will implement in upcoming lessons. This test will help us verify the code and check if it is working fine

```
// ** Test Functions

  #[test_only]
  public fun init_for_testing(ctx: &mut TxContext) {
    init(USDC {}, ctx);
  }
}
```

## Complete code

Here’s the complete code for your ease.

```
module dex::usdc {
  use std::option;

  use sui::url;
  use sui::transfer;
  use sui::coin;
  use sui::tx_context::{Self, TxContext};

  // ** Structs

  // One Time Witness to create a Current in Sui
  // This struct has the drop ability so it cannot be transferred nor stored. 
  // It allows the Network to know it is a unique type

  struct USDC has drop {}

  // The init function runs once on Module creation and accepts a one-time witness as the first argument
  // Witness is a struct with 1 ability, drop, it guarantees that there is only one in the entire network as you can only get it in the init function
  
fun init(witness: USDC, ctx: &mut TxContext) {
      // We call the create_currency
      // Creating a currency requires a one-time witness to ensure it is a unique coin
      // Only the holder of the TreasuryCap is allowed to mint and burn this coin
      // Metadata holds all the information about the coin, so other applications query it
      
			let (treasury_cap, metadata) = coin::create_currency<USDC>(
            witness, // One time witness
            9, // Decimals of the coin
            b"USDC", // Symbol of the coin
            b"USDC Coin", // Name of the coin
            b"A stable coin issued by Circle", // Description of the coin
            option::some(url::new_unsafe_from_bytes(b"https://s3.coinmarketcap.com/static-gravity/image/5a8229787b5e4c809b5914eef709b59a.png")), // An image of the Coin
            ctx
        );

      // We send the treasury capability to the deployer

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

      // Objects defined in different modules need to use the public_ transfer functions
      
			transfer::public_share_object(metadata);
  }

  // ** Test Functions

  #[test_only]
  public fun init_for_testing(ctx: &mut TxContext) {
    init(USDC {}, ctx);
  }
}
```

## That’s a wrap

USDC contract will help us create and fill our balance with USDC coins. So that we can easily convert USDC coins to ETH or ETH to USDC coins. Next, we will implement the Dex smart contract that will help us swap the ETH and USDC coins and keep a record of the balances of our tokens.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/3.%20Build%20Your%20Swap%20DApp/2.%20Writing%20the%20USDC%20Smart%20Contract.md

Writing the USDC Smart Contract

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/3.%20Build%20Your%20Swap%20DApp/3.%20Writing%20the%20Dex%20Smart%20Contract.md

Writing the Dex Smart Contract

# Deploy the Dex DApp

Great work on setting up your development environment for Move on Sui. In this lesson, we will learn to run and deploy a `dex` Move project on the Sui blockchain and explore it in the Explorer.

## Update `Move.toml` file

To successfully deploy your Dex Sui project, it is necessary to update the `Move.toml` file. This update is required to ensure that certain dependencies can be easily installed and used. During the implementation of the contracts, you may have noticed the use of some libraries. To install and use these libraries, please update the `Move.toml` file with the following information.

**Note:** Remember to use same package name as you used while creating the Move on Sui project.

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

[dependencies]
MoveStdlib = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/move-stdlib", rev = "testnet-v1.14.0" }
Sui = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/sui-framework", rev = "testnet-v1.14.0" }
DeepBook = { git = "https://github.com/MystenLabs/sui.git", subdir = "crates/sui-framework/packages/deepbook", rev = "testnet-v1.14.0" }

[addresses]
dex = "0x0"
std = "0x1"
sui = "0x2"
deepbook = "0xdee9"
```

## Build and publish on Sui

Now let’s build our Move file using the following command. Remember to move to the `dex` folder using `cd dex` command.

```
sui move build
```

This will generate an output like the following:

![deploy-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/4.%20Deploy%20the%20DApp/assets/deploy-1.png?raw=true)

**Note**: Ignore all the warnings and move forward.

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

![deploy-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/4.%20Deploy%20the%20DApp/assets/deploy-2.png?raw=true)

### Set up the development environment

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

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

### Publish the contract

Run the following command to publish the Move project to the testnet finally:

```
sui client publish --skip-dependency-verification --gas-budget 90000000
```
Note: When you are deploying on production, we recommend not to use the `--skip-dependency-verification` flag

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

![deploy-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/4.%20Deploy%20the%20DApp/assets/deploy-3.png?raw=true)

- **Note**: Ignore all the warnings and move forward. But if you encounter an “Insufficient funds” error then you can head over to the [Sui Testnet faucet discord channel](https://discord.com/channels/916379725201563759/1037811694564560966) and paste “!faucet [YOUR_ADDRESS]” to receive 10 SUI tokens.
    
    

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

![deploy-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/4.%20Deploy%20the%20DApp/assets/deploy-4.png?raw=true)

Whoo! You did great but wait! Now you need to create the pool. A pool is something that will fill your dex app with tokens. To do this, we need to run the following functions present in `sources/dex.move` file.

1. `create_pool`
2. `create_state`
3. `fill_pool`

Here’s the screenshot of these functions from the `sources/dex.move` file.

![pool-code.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/4.%20Deploy%20the%20DApp/assets/pool-code.png?raw=true)

To run these functions we need 100 SUI tokens in our testnet wallet address. It is almost impossible to get 100 SUI tokens for free even for the testnet account.

So, to solve this problem we have already created a pool for you on the following address. Here is the Package ID of our DEX contract

Note: If you are looking to build a end to end product on Sui, please reach out to the Metaschool team and we will help you with the 100 Sui tokens.

```
0xa1dce324bcf781692a358adb27bd105844231d35863b5c99f94e54801d653788
```

And the following is the DEX Storage ID, which we will use in the next lesson.

```
0x6912d83e2c4868386511fe3f6f18aff9399b9ad5cae2d97943766e2ff160ab25
```

## That’s a wrap

In conclusion, this lesson introduced 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 testnet. Congratulations on completing this lesson!


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/4.%20Deploy%20the%20DApp/1.%20Deploy%20the%20Dex%20DApp.md

Deploy the Dex DApp

# Set Up the Frontend

Kudos! We have deployed our dApp. We are all set to proceed in setting up our frontend. No more waiting, let’s go!

## Setting up the Dex frontend

Open a new terminal in your `dex` directory or continue using the previous terminal if opened. 

Run the following command to clone the frontend directory:

```
git clone https://github.com/0xmetaschool/sui-dex-frontend
```

The front end will have the following file structure.

![frontend-1.1.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-1.1.png?raw=true)

Let’s install our dependencies:

```
yarn install
```

## Find the dex package ID

Next, we need to find the package ID of our `dex` module, that we implemented while writing the contracts. Follow the following steps to do so.

1. Head over to the Sui Explorer and enter the Transaction Digest that you got in the last lesson in the search bar.
    
    ![frontend-1.gif](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-1.gif?raw=true)
    

1. You can see the sidebar with the “Summary” heading. Please scroll to the end of the sidebar to find the “Publish” field.
    
    ![frontend-2.gif](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-2.gif?raw=true)
    

1. Now, open the “Object” field by clicking on the “>” sign in the “Publish” field and click on the “dex” module.
    
    ![frontend-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-3.png?raw=true)
    

You will see the page something like this:

![frontend-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-4.png?raw=true)

1. Copy your package ID, as mentioned in the following screenshot. This will be your dex package ID that we will use in our front end.
    
    ![frontend-5.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-5.png?raw=true)
    
    ## Set Up environment variables
    
    Why do we even need a dex package ID? We need the ID to connect our Move project with the front end. Remember we discussed in the last lesson that to run the dex app we need a pool. So, head over to the `.env` file in your cloned frontend, and use the following package ID as this package ID has already filled the pool with 100 SUI for your ease.
    
    ```
    DEX_PACKAGE_ID=0xa1dce324bcf781692a358adb27bd105844231d35863b5c99f94e54801d653788
    ```
    
    Also, if the .env file is not updated remember to paste the following `DEX_STORAGE_ID` as well.
    
    ```
    DEX_STORAGE_ID=0x6912d83e2c4868386511fe3f6f18aff9399b9ad5cae2d97943766e2ff160ab25
    ```
    
    If you have created your pool then you can use your IDs. We need to fill the pool because without filling the pool the app will give you errors.
    
    ## Run the frontend
    
    To run the frontend, run the following command in your terminal.
    
    ```
    yarn dev
    ```
    
    The command will give you an output like this:
    
    ![frontend-6.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-6.png?raw=true)
    
    Head over to the link, the `local` field is showing to you. You will see something like this in your browser.
    
    ![frontend-7.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-7.png?raw=true)
    
    Here, you can see there is an option to sign in using Google. When you try to click on the “Sign with Google” button it will give the following response.
    
    ![frontend-8.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/frontend-8.png?raw=true)
    
     So, we need Google Cloud credentials that will allow us to sign in using Google and use our application.
    
    ## That’s a wrap
    
    Phew, we’re so proud of you for setting up the front end all by yourself. Next, we will set up the Google Cloud credentials and get our front end up and running.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/1.%20Set%20Up%20the%20Frontend.md

# Set Up the Google Credentials

We’re so proud of you for coming this far and setting up the front end for your DeFi app. In this lesson, we will set up the Google credentials.

## Set up the Google credentials

Follow the following steps to set up the Google Cloud account and fetch the client ID that you’re going to use in your front-end application.

1. Head over to the [Google Cloud Dashboard](https://console.cloud.google.com/home/dashboard) and log in with your Google account. You will a page like the following, after logging in.
    
    ![google-setup-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-1.png?raw=true)
    

1. At the sidebar, you can see the “APIs & Services” field. Head over to it and click on “Credentials.”
    
    ![google-setup-2.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-2.png?raw=true)
    

You’ll see a page like this:

![google-setup-3.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-3.png?raw=true)

1. Now, click on the “CREATE PROJECT”, fill in the fields with the following data, and click on the “CREATE” button.
    1. Project name: Sui App Login
    2. Location: Leave this field as is

Here’s how we’re filling the fields.

![google-setup-4.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-4.png?raw=true)

You’ll see a page like this, after creating the project.

![google-setup-5.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-5.png?raw=true)

1. To create the credentials, click on “+ CREATE CREDENTIALS” button, and then select “OAuth client ID”.
    
    ![google-setup-6.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-6.png?raw=true)
    
    1. Next, if you see a page like the following, click on the “CONFIGURE CONSENT SCREEN” button.
        
        ![google-setup-7.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-7.png?raw=true)
        
    2. Select the “External” option so that any user can use your application, then click on the “CREATE” button.
        
        ![google-setup-8.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-8.png?raw=true)
        
    
    You’ll see a page like the following after clicking on the “CREATE” button.
    
    ![google-setup-9.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-9.png?raw=true)
    
    1. You need to fill in the App information now. Fill in the following fields, skip any other fields, and click on the “SAVE AND CONTINUE” button after filling in the information.
        1. **App name**: Sui App Login
        2. **User Support Email**: Here, you can fill in your Email ID
        3. **Authorized domains**: Click on the “+ Add Domain” button and enter the following link - `sui.io`
        4. **Developer contact information**: Fill this field with your Email ID
    2. Now, you’ll see the page like the following. Move to the end of the page, click on the “SAVE AND CONTINUE” button, and continue without making any changes here.
        
        ![google-setup-10.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-10.png?raw=true)
        
    3. Next, you’ll see the following page. Again, click on “SAVE AND CONTINUE” button, and move forward.
        
        ![google-setup-11.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-11.png?raw=true)
        
        1. At last, you’ll see the following page. Move to the end of the page and click on the “BACK TO DASHBOARD” button.
            
            ![google-setup-12.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-12.png?raw=true)
            
        2. The following page will appear. Move back to the credentials page by clicking on the “Credentials” page.
            
            ![google-setup-13.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-13.png?raw=true)
            
        3. Now, again select “+ CREATE CREDENTIALS” and then “OAuth client ID”.
            
            ![google-setup-15.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-15.png?raw=true)
            
        4. Select “Web Application” from the “Application type” scroll bar.
            
            ![google-setup-16.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-16.png?raw=true)
            
            1. Fill in the “Name” of your application, “Authorized redirect URIs” with the `http://localhost:3000/` and `http://127.0.0.1:3000/` URI, and click on the “CREATE” button.
                
                ![google-setup-17.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-17.png?raw=true)
                
            
        
        15. After creating the client ID, the following page will appear. Copy the Client ID. We will paste this client ID to our `.env` file in the frontend.
        
        ![google-setup-18.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-18.png?raw=true)
        
        Or you can copy the Client ID from here.
        
        ![google-setup-19.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/google-setup-19.png?raw=true)
        

16. Lastly, we need to make our app public on Google Cloud. So that anyone, including you, can log in without any restrictions. To do this, head over to the “OAuth consent screen” from the side bar and click on the “Publish App” button.

![publish-app.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/assets/publish-app.png?raw=true)

## Paste the Client ID to the .env file

Head back to your front end and find the `.env` file. If not present, please create the file at root directory. Paste the following line to `.env` file and replace `YOUR_GOOGLE_CLIENT_ID` with the Client ID you copied from the Google cloud.

```
NEXT_PUBLIC_CLIENT_ID_GOOGLE=YOUR_GOOGLE_CLIENT_ID
```

## That’s a wrap

Great work on setting up the Google Cloud client ID. In the next lesson, we will set up the ZK login and get our front end running.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/2.%20Set%20Up%20the%20Google%20Credentials.md

Set Up the Google Credentials

# Interact With the Frontend

You have successfully set up everything for your front end, but there is one final step remaining. In this lesson, we will configure the ZK login credentials, run the front end, explore its features, and learn how to interact with Sui Move contracts through the front end.

## Set up ZK Login

Please navigate to the `.env` file in your frontend directory and add the following line. We have already configured ZK Login for your convenience, so you can simply copy and paste the ZK Prover URL without having to spend hours on its setup.

```
URL_ZK_PROVER=http://175.41.177.22:8001/v1
```

If you want to set up ZK Login on your own, please follow the instructions given in the [Readme.md](http://Readme.md) file provided in this link.

## Interact with the frontend

Let's run our app by entering the following command in your terminal, located in the frontend directory, now that all credentials have been set up.

```
yarn dev
```

This time try again to log in by clicking on the “Sign with Google” button. Verify you Google account and then log in. After logging in wait for a few seconds for ZK to get connected with your app. After the request is completed, you will see a page like this.

![frontend-interact-1.png](https://github.com/0xmetaschool/Learning-Projects/blob/ba2ce8dea0997931621928704f03f1a8483ecc0d/Build%20the%20Token%20Dex%20DApp/1.%20Getting%20Started/assets/frontend-interact-1.png?raw=true)

Let’s play around with different features of our application and see how it works.

1. First, click on the “Mint SUI” button to increase your SUI balance.
2. To fill your USDC and ETH balance, click on the “Mint ETH” and “Mint USDC” buttons separately.
3. Before swapping, it is necessary to increase balances because, without any ETH or USDC, you will not be able to swap the tokens.
4. To swap the tokens, fill in the balance and click on the “Swap” button.
5. If you want to swap ETH to USDC or USDC to ETH, click on the arrow button to switch their places.

## That’s a wrap

We’re so proud of you for completing the course and setting up your own Dex application. In the next lesson, we will wrap up the course and overview what you have learned so far.


https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/5.%20Work%20With%20the%20Frontend/3.%20Interact%20With%20the%20Frontend.md

# Let’s Wrap It Up

Congratulations on reaching the end of this comprehensive guide to building a decentralized application (dApp) on the Sui blockchain! Throughout this learning journey, you've gained valuable insights into the Sui network, mastered the Move programming language, and successfully crafted and deployed a smart contract for a dex dApp. Let's reflect on your achievements and outline the key takeaways.

## Key Learnings:

1. **Sui Ecosystem Exploration:**
    - You've familiarized yourself with the Sui network, understanding its capabilities and how it stands out in the blockchain space.
2. **Move Advance Concepts:**
    - You implemented the Move project from start to end and implemented all of the advanced concepts you studied in the second course of this Sui Learning Path.
3. **Development Environment Setup:**
    - Set up the Sui toolchain and ensure your development environment is ready for creating decentralized applications.
4. **Smart Contract Development:**
    - Progressed through the step-by-step process of coding a smart contract for a dex dApp. From data structure setup to deployment, you've seen how Move empowers developers in the Sui ecosystem.
5. **Frontend Integration:**
    - Created a frontend for your dApp, showcasing the seamless interaction between smart contracts and user interfaces.
6. **Interaction:**
    - Learned how to interact with your dApp, ensuring that it performs as expected.

## 🛠 Contribute to this project!

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

Here’s the GREAT news for you! This is an open-source project, you can find the tutorial markdown files [here](https://github.com/0xmetaschool/Learning-Projects). If you find any issues in the course, please feel free to resolve it.

We, at Metaschool, love love love contributions by our community and we give acknowledgment to contributors in our discord and GitHub profile too. Also, don’t forget to star ⭐️ our repository! we will be very thankful! ♥️

## 🎊 Congratulations

Thank you for joining us on this exciting journey into the world of Fuel and decentralized applications. Your commitment to learning and building in the blockchain space is commendable. Best of luck in all your future endeavors as you continue to shape the future of decentralized technologies!

WAGMI! Peace out! ✌🏻🔮

---

**Assignment Title:** What did you like about this course? Share with your LinkedIn and Twitter fam and share the screenshot with us.

Description**:** Share With Your LinkedIn and Twitter Fam.

https://raw.githubusercontent.com/0xmetaschool/Learning-Projects/main/Build%20the%20Token%20Dex%20DApp/6.%20Wrap%20Up%20the%20Course/1.%20Let%E2%80%99s%20Wrap%20It%20Up.md

Warden Protocol

30 days of solidity

Fuel Marathon

Aptos Marathon

Core Marathon

Sui Marathon

Master Sui Move, Build Beyond

AI Templates

TicTacToeGPT

MockInterviewerGPT

CSSGeneratorGPT

FinanceGPT

LearnLanguageGPT

Castle.ai

FlashcardGPT

DatingCoachGPT

TriviaQuizGPT

CrosswordGPT

AI Tools

Master Sui Move, Build Beyond