Move Intro Course

https://github.com/sui-foundation/sui-move-intro-course
Admin
An introductory course on the Move programming language for building smart contracts on the Sui...
Tokens:35,631
Snippets:386
Trust Score:9.3
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Sui Binary

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Install the Sui binary using one of the supported methods to obtain the Move compiler and CLI. Recommended method is via suiup.

```bash
# Recommended: install via suiup
suiup install sui
```

```bash
# macOS via Homebrew
brew install sui
```

```bash
# Windows via Chocolatey
choco install sui
```

```bash
# Build from source with Cargo
cargo install --git https://github.com/MystenLabs/sui.git sui --branch mainnet
rustup update stable
```

```bash
# Verify installation
sui --version
```

```bash
# Docker alternative
docker pull mysten/sui-tools:devnet
docker run --name suidevcontainer -itd mysten/sui-tools:devnet
docker exec -it suidevcontainer bash
```

--------------------------------

### Install Sui using suiup

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Use the suiup tool for a simple installation and management of different Sui binary versions.

```bash
suiup install sui
```

--------------------------------

### Install Sui using Chocolatey (Windows)

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Install the Sui binary on Windows using the Chocolatey package manager.

```bash
choco install sui
```

--------------------------------

### Kiosk Full Flow Example (CLI)

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/5_transfer_policy.md

Example of a full kiosk transaction using the Sui client CLI. It demonstrates buying an item, calculating and paying the royalty fee, confirming the request, and transferring ownership.

```bash
export KIOSK_TSHIRT=<Object ID of the listed TShirt>
sui client ptb \
--assign price 10000 \
--split-coins gas "[price]" \
--assign coin \
--move-call $KIOSK_PACKAGE_ID::kiosk::buy @$KIOSK @$KIOSK_TSHIRT coin.0 \
--assign buy_res \
--move-call $KIOSK_PACKAGE_ID::fixed_royalty_rule::fee_amount "<$KIOSK_PACKAGE_ID::kiosk::TShirt>" @$KIOSK_TRANSFER_POLICY price \
--assign fee_amount \
--split-coins gas "[fee_amount]"\
--assign coin \
--move-call $KIOSK_PACKAGE_ID::fixed_royalty_rule::pay "<$KIOSK_PACKAGE_ID::kiosk::TShirt>" @$KIOSK_TRANSFER_POLICY buy_res.1 coin.0 \
--move-call $KIOSK_PACKAGE_ID::kiosk::confirm_request  @$KIOSK_TRANSFER_POLICY buy_res.1 \
--move-call 0x2::transfer::public_transfer "<$KIOSK_PACKAGE_ID::kiosk::TShirt>" buy_res.0 <buyer address> \

```

--------------------------------

### Method Call Syntax Examples

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/3_custom_types_and_abilities.md

Demonstrates both traditional function call syntax and the more concise method call syntax in Move.

```move
// Traditional function call syntax
let sender = tx_context::sender(ctx);
let text = string::utf8(b"Hello World!");

// Method call syntax
let sender = ctx.sender();
let text = b"Hello World!".to_string();
```

--------------------------------

### Import Standard Library Module

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/3_custom_types_and_abilities.md

Example of importing a module from the Sui Standard Library using the 'use' keyword.

```move
use std::string;
```

--------------------------------

### Install Sui using Homebrew (macOS)

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Install the Sui binary on macOS using the Homebrew package manager.

```bash
brew install sui
```

--------------------------------

### Verify Sui Installation

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Check if the Sui binaries were installed successfully by running the version command.

```bash
sui --version
```

--------------------------------

### Install Move Analyzer with Sui Address Support

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Install the Move Analyzer VS Code plugin and add support for Sui-style wallet addresses.

```bash
cargo install --git https://github.com/move-language/move move-analyzer --features "address20"
```

--------------------------------

### Initialize Sui Package

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/3_custom_types_and_abilities.md

Command to initialize a new Sui package. Ensure Sui binaries are installed.

```bash
sui move new hello_world
```

--------------------------------

### Full Flashloan PTB Example via CLI

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Illustrates constructing a complex PTB for a flashloan scenario using the Sui CLI. This involves borrowing, minting an NFT, selling it, and repaying the loan, chaining multiple Move calls.

```bash
# Full flashloan PTB: borrow -> mint NFT -> sell NFT -> repay
export LOAN_PACKAGE_ID=<package id>
export LOAN_POOL_ID=<LoanPool object id>

sui client ptb \
  --move-call $LOAN_PACKAGE_ID::flashloan::borrow @$LOAN_POOL_ID 10000 \
  --assign borrow_res \
  --move-call $LOAN_PACKAGE_ID::flashloan::mint_nft borrow_res.0 \
  --assign nft \
  --move-call $LOAN_PACKAGE_ID::flashloan::sell_nft nft \
  --assign repay_coin \
  --move-call $LOAN_PACKAGE_ID::flashloan::repay @$LOAN_POOL_ID borrow_res.1 repay_coin
```

--------------------------------

### Build Sui using Cargo (macOS, Linux)

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Install and build Sui locally using Cargo. Ensure you have Rust installed and updated.

```bash
cargo install --git https://github.com/MystenLabs/sui.git sui --branch mainnet
```

```bash
rustup update stable
```

--------------------------------

### Initialize Marketplace Contract

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/5_deployment_and_testing.md

Initializes the marketplace contract by calling the `create` entry function. This command specifies the type of fungible token the marketplace will accept, using the native SUI token in this example.

```bash
sui client call --function create --module marketplace --package $PACKAGE_ID --type-args 0x2::sui::SUI
```

--------------------------------

### Build PTB via CLI: Split Coins, Call Function, Chain Results

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Demonstrates building a Programmable Transaction Block (PTB) using the Sui CLI. This example shows how to split coins, call a Move function, and assign the result to a variable for subsequent use.

```bash
# Build a PTB via CLI: split coins, call a function, assign and chain results
sui client ptb \
  --split-coins gas "[10000]" \
  --assign coin \
  --move-call $PACKAGE_ID::module::function @$SHARED_OBJECT_ID coin.0
```

--------------------------------

### Sui Kiosk Purchase Command

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Example bash command to perform a full kiosk purchase, including setting up environment variables and executing a series of `sui client ptb` commands to handle coin splitting, calling the buy function, calculating royalty fees, paying fees, and confirming the request.

```bash
export KIOSK_PACKAGE_ID=<package id>
export KIOSK=<Kiosk object id>
export KIOSK_TRANSFER_POLICY=<TransferPolicy object id>
export KIOSK_TSHIRT=<listed TShirt object id>

# Full kiosk purchase PTB (with royalty fee rule)
sui client ptb \
  --assign price 10000 \
  --split-coins gas "[price]" \
  --assign coin \
  --move-call $KIOSK_PACKAGE_ID::kiosk::buy @$KIOSK @$KIOSK_TSHIRT coin.0 \
  --assign buy_res \
  --move-call $KIOSK_PACKAGE_ID::fixed_royalty_rule::fee_amount 
      "<$KIOSK_PACKAGE_ID::kiosk::TShirt>" @$KIOSK_TRANSFER_POLICY price \
  --assign fee_amount \
  --split-coins gas "[fee_amount]" \
  --assign fee_coin \
  --move-call $KIOSK_PACKAGE_ID::fixed_royalty_rule::pay 
      "<$KIOSK_PACKAGE_ID::kiosk::TShirt>" @$KIOSK_TRANSFER_POLICY buy_res.1 fee_coin.0 \
  --move-call $KIOSK_PACKAGE_ID::kiosk::confirm_request 
      @$KIOSK_TRANSFER_POLICY buy_res.1 \
  --move-call 0x2::transfer::public_transfer 
      "<$KIOSK_PACKAGE_ID::kiosk::TShirt>" buy_res.0 <buyer address>
```

--------------------------------

### Witness Pattern Example: Guardian<T>

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/3_witness_design_pattern.md

This module demonstrates the Witness pattern using `PEACE` as the witness resource to control the instantiation of `Guardian<T>`. The `PEACE` resource must have the `drop` ability and is consumed in `create_guardian` to ensure only one `Guardian` can be created.

```move
/// Module that defines a generic type `Guardian<T>` which can only be
/// instantiated with a witness.
module witness::peace;

/// Phantom parameter T can only be initialized in the `create_guardian`
/// function. But the types passed here must have `drop`.
public struct Guardian<phantom T: drop> has key, store {
    id: UID
}

/// This type is the witness resource and is intended to be used only once.
public struct PEACE has drop {}

/// The first argument of this function is an actual instance of the
/// type T with `drop` ability. It is dropped as soon as received.
public fun create_guardian<T: drop>(_: T, ctx: &mut TxContext): Guardian<T> {
    Guardian { id: object::new(ctx) }
}

/// Module initializer is the best way to ensure that the
/// code is called only once. With `Witness` pattern it is
/// often the best practice.
fun init(witness: PEACE, ctx: &mut TxContext) {
    transfer::public_transfer(create_guardian(witness, ctx), ctx.sender())
}
```

--------------------------------

### Minting a Coin in Test Scenario

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/7_unit_testing.md

Advance to the next transaction, retrieve the TreasuryCap, mint a Coin object, and return the TreasuryCap to the sender. Use scenario.take_from_sender to get objects and test_scenario::return_to_address to return them.

```move
scenario.next_tx(addr1);
{
    let mut treasurycap = scenario.take_from_sender<TreasuryCap<MANAGED>>();
    managed::mint(&mut treasurycap, 100, addr1, scenario.ctx());
    test_scenario::return_to_address<TreasuryCap<MANAGED>>(
        addr1,
        treasurycap,
    );
};
```

--------------------------------

### Basic BCS Serialization and Deserialization in JavaScript

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/advanced-topics/BCS_encoding/lessons/BCS_encoding.md

Demonstrates serializing and deserializing integer, array, and string types using the @mysten/bcs library. Ensure the library is installed via npm.

```javascript
import { bcs } from "@mysten/bcs";

// Define some test data types
const integer = 10;
const array = [1, 2, 3, 4];
const string = "test string";

// use .serialize() to serialize data
const ser_integer = bcs.u16().serialize(integer);
const ser_array = bcs.vector(bcs.u8()).serialize(array);
const ser_string = bcs.string().serialize(string);

// use .parse() to deserialize data
const de_integer = bcs.u16().parse(ser_integer.toBytes());
const de_array = bcs.vector(bcs.u8()).parse(ser_array.toBytes());
const de_string = bcs.string().parse(ser_string.toBytes());
```

--------------------------------

### Call an Entry Function on Sui

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/5_contract_deployment.md

Execute an entry function (transaction endpoint) of your deployed smart contract using the Sui CLI. This example calls the 'mint' function.

```bash
sui client call --function mint --module hello_world --package $PACKAGE_ID
```

--------------------------------

### NFT Struct and Functions in Move

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/2_hot_potato_pattern.md

Defines a dummy NFT structure and functions for minting and selling. These are core components for the flashloan example.

```move
/// A dummy NFT to represent the flashloan functionality
public struct NFT has key {
    id: UID,
    price: Balance<SUI>,
}

/// Mint NFT
public fun mint_nft(payment: Coin<SUI>, ctx: &mut TxContext): NFT {
    NFT {
        id: object::new(ctx),
        price: payment.into_balance(),
    }
}

/// Sell NFT
public fun sell_nft(nft: NFT, ctx: &mut TxContext): Coin<SUI> {
    let NFT { id, price, .. } = nft;
    id.delete();
    price.into_coin(ctx)
}
```

--------------------------------

### Pull and Run Sui Docker Image

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Use the official Sui Docker image for a pre-configured development environment. This includes pulling the image and starting a container.

```bash
docker pull mysten/sui-tools:devnet
```

```bash
docker run --name suidevcontainer -itd mysten/sui-tools:devnet
```

```bash
docker exec -it suidevcontainer bash
```

--------------------------------

### Export Kiosk Package ID

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/4_kiosk_basic_usage.md

Export the package ID of the example kiosk smart contract for later use in commands.

```bash
export KIOSK_PACKAGE_ID=<Package ID of example kiosk smart contract>
```

--------------------------------

### Publish a Sui Package

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/5_contract_deployment.md

Use the Sui CLI to publish your Move package to the network. Ensure you have sufficient tokens for gas fees.

```bash
sui client publish [absolute file path to the package that needs to be published]
```

--------------------------------

### Create Kiosk via CLI

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/4_kiosk_basic_usage.md

Use the Sui client to call the `new_kiosk` function on the deployed smart contract.

```bash
sui client call --package $KIOSK_PACKAGE_ID --module kiosk --function new_kiosk
```

--------------------------------

### Sample Move.toml Manifest

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/2_sui_project_structure.md

This is a sample Move.toml file generated by the Sui CLI. It includes sections for package metadata, dependencies, dev-dependencies, addresses, and dev-addresses.

```toml
[package]
name = "hello_world"
edition = "2024.beta" # edition = "legacy" to use legacy (pre-2024) Move
# license = ""           # e.g., "MIT", "GPL", "Apache 2.0"
# authors = ["..."]      # e.g., ["Joe Smith (joesmith@noemail.com)", "John Snow (johnsnow@noemail.com)"]

[dependencies]
# For remote import, use the "{ git = \"...\", subdir = \"...\", rev = \"...\" }".
# Revision can be a branch, a tag, and a commit hash.
# MyRemotePackage = { git = "https://some.remote/host.git", subdir = "remote/path", rev = "main" }

# For local dependencies use `local = path`. Path is relative to the package root
# Local = { local = "../path/to" }

# To resolve a version conflict and force a specific version for dependency
# override use `override = true`
# Override = { local = "../conflicting/version", override = true }

[addresses]
hello_world = "0x0"

# Named addresses will be accessible in Move as "@name". They're also exported:
# for example, `std = "0x1"` is exported by the Standard Library.
# alice = "0xA11CE"

[dev-dependencies]
# The dev-dependencies section allows overriding dependencies for "--test" and
# "--dev" modes. You can introduce test-only dependencies here.
# Local = { local = "../path/to/dev-build" }

[dev-addresses]
# The dev-addresses section allows overwriting named addresses for the "--test"
# and "--dev" modes.
# alice = "0xB0B"

```

--------------------------------

### Define Locker Custom Type

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/6_clock_and_locked_coin.md

Defines the Locker custom type to store vesting coin information, including start date, final date, original balance, and current balance.

```move
/// Transferable object for storing the vesting coins
public struct Locker has key, store {
    id: UID,
    start_date: u64,
    final_date: u64,
    original_balance: u64,
    current_balance: Balance<LOCKED_COIN>

}
```

--------------------------------

### Initialize Capability in Module

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-two/lessons/6_capability_design_pattern.md

The `init` function is called once on module publish to create and transfer the initial capability object to the publisher's address.

```move
/// Called only once on module publish.
fun init(ctx: &mut TxContext) {
    transfer::transfer(TeacherCap {
        id: object::new(ctx)
    }, ctx.sender())
}
```

--------------------------------

### Add Royalty Rule Command

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Bash command to add a fixed royalty rule to a Sui Transfer Policy. This example sets a 0.1% fee (10 basis points) with a minimum of 100 MIST.

```bash
# Add rule: 0.1% fee (10 basis points), 100 MIST minimum
sui client call \
  --package $KIOSK_PACKAGE_ID \
  --module fixed_royalty_rule \
  --function add \
  --args $KIOSK_TRANSFER_POLICY $KIOSK_TRANSFER_POLICY_CAP 10 100 \
  --type-args $KIOSK_PACKAGE_ID::kiosk::TShirt
```

--------------------------------

### Execute Flashloan, Mint, Sell, and Repay

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/2_hot_potato_pattern.md

Executes a complete flashloan cycle: borrows SUI, mints an NFT with it, sells the NFT, and repays the borrowed amount, all within a single PTB transaction.

```bash
sui client ptb \
--move-call $LOAN_PACKAGE_ID::flashloan::borrow @$LOAN_POOL_ID 10000 \
--assign borrow_res \
--move-call $LOAN_PACKAGE_ID::flashloan::mint_nft borrow_res.0 \
--assign nft \
--move-call $LOAN_PACKAGE_ID::flashloan::sell_nft nft \
--assign repay_coin \
--move-call $LOAN_PACKAGE_ID::flashloan::repay @$LOAN_POOL_ID borrow_res.1 repay_coin \

```

--------------------------------

### Define and Operate on Move Vectors

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/1_homogeneous_collections.md

Defines a `Vector` for a specified type and a generic `Vector`. Includes functions to create, push, pop, and get the size of a generic vector. All elements in a vector must be of the same type.

```move
module collection::vector;

public struct Widget {}

#[allow(unused_field)]
// Vector for a specified type
public struct WidgetVector {
    widgets: vector<Widget>,
}

// Vector for a generic type
public struct GenericVector<T> {
    values: vector<T>,
}

// Creates a GenericVector that holds a generic type T
public fun create<T>(): GenericVector<T> {
    GenericVector<T> {
        values: vector::empty<T>(),
    }
}

// Push a value of type T into a GenericVector
public fun put<T>(mut vec: &mut GenericVector<T>, value: T) {
    vec.values.push_back(value);
}

// Pops a value of type T from a GenericVector
public fun remove<T>(mut vec: &mut GenericVector<T>): T {
    vec.values.pop_back()
}

// Returns the size of a given GenericVector
public fun size<T>(vec: &GenericVector<T>): u64 {
    vec.values.length()
}
```

--------------------------------

### Create an Entry Function to Mint an Object in Move

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/4_functions.md

This entry function creates a new HelloWorldObject and transfers it to the transaction sender. Entry functions must have no return value and are called directly by transactions. It requires a mutable reference to TxContext.

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

--------------------------------

### Buy and Take Widget Item

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/5_deployment_and_testing.md

Purchases the listed widget item from the marketplace. This command requires the marketplace ID, item ID, payment coin ID, and type arguments for the item and payment coin.

```bash
sui client call --function buy_and_take --module marketplace --package $PACKAGE_ID --args $MARKET_ID $ITEM_ID $PAYMENT_ID --type-args $PACKAGE_ID::widget::Widget 0x2::sui::SUI
```

--------------------------------

### List Sui Network Aliases

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Display all currently configured network aliases for the Sui CLI.

```bash
sui client envs
```

--------------------------------

### Sui CLI Command for Withdrawing Vested Tokens

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Example command to call the `withdraw_vested` function using the Sui CLI. Ensure to replace placeholders like `$PACKAGE_ID` and `$LOCKER_ID` with actual values. The Clock object ID is hardcoded as `0x6`.

```bash
# Pass 0x6 as the Clock object argument
sui client call \
  --function withdraw_vested --module locked_coin --package $PACKAGE_ID \
  --args $LOCKER_ID 0x6
```

--------------------------------

### Initialize a New Sui Move Package

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/2_sui_project_structure.md

Use the sui move new command to create a skeleton Sui package. This command generates the project root, Move.toml manifest, and source/test directories.

```bash
sui move new <PACKAGE NAME>
```

```bash
sui move new hello_world
```

--------------------------------

### Mint Tokens into a Time-Locked Locker

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Mints tokens and locks them in a Locker struct, which includes start date, final date, original balance, and current balance. Requires a TreasuryCap, recipient address, amount, lock-up duration, and a Clock object.

```move
use sui::clock::{Self, Clock};
use sui::coin::{Self, TreasuryCap};
use sui::balance::{Self, Balance};

public struct LOCKED_COIN has drop {}

public struct Locker has key, store {
    id: UID,
    start_date: u64,
    final_date: u64,
    original_balance: u64,
    current_balance: Balance<LOCKED_COIN>,
}

/// Mint tokens into a time-locked Locker
public fun locked_mint(
    treasury_cap: &mut TreasuryCap<LOCKED_COIN>,
    recipient: address,
    amount: u64,
    lock_up_duration: u64,  // milliseconds
    clock: &Clock,
    ctx: &mut TxContext,
) {
    let coin = treasury_cap.mint(amount, ctx);
    let start_date = clock.timestamp_ms();
    let final_date = start_date + lock_up_duration;
    transfer::public_transfer(
        Locker {
            id: object::new(ctx),
            start_date,
            final_date,
            original_balance: amount,
            current_balance: coin.into_balance(),
        },
        recipient,
    );
}
```

--------------------------------

### Calling Generic Function in Move and CLI

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Demonstrates how to call a generic function 'create_box' in Move code and from the Sui CLI, specifying type arguments.

```move
// Calling a generic function in Move code
let bool_box = storage::create_box<bool>(true, ctx);
let u64_box  = storage::create_box<u64>(1_000_000, ctx);
```

```bash
# Calling a generic function from CLI — pass type with --type-args
sui client call \
  --package $PACKAGE \
  --module storage \
  --function create_box \
  --args $OBJECT_ID \
  --type-args 0x2::sui::SUI
```

--------------------------------

### Define HelloWorldObject Struct

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/3_custom_types_and_abilities.md

Defines a custom struct 'HelloWorldObject' with 'key' and 'store' abilities, making it an asset. It includes a UID for global storage and a string field.

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

--------------------------------

### Sui CLI Network and Wallet Management

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Manage networks, addresses, and gas using the Sui CLI client commands. Initialize the client and follow prompts to connect to devnet.

```bash
# Initialize client (follow prompts to connect to devnet, choose ed25519)
sui client
```

```bash
# List and switch networks
sui client envs
sui client switch --env testnet
sui client new-env --alias testnet --rpc https://fullnode.testnet.sui.io:443
```

```bash
# Check addresses and gas
sui client addresses
sui client active-address
sui client gas
```

--------------------------------

### Initialize Module State in Scenario

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/7_unit_testing.md

Call the test_init function within the scenario's context to initialize the module's state before running other test operations.

```move
// Run the managed coin module init function
{
    managed::test_init(scenario.ctx())
};
```

--------------------------------

### Initialize Test Scenario

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/7_unit_testing.md

Begin a multi-transaction test scenario with a specified sender address. The Scenario object must be cleaned up using scenario.end().

```move
// Initialize a mock sender address
let addr1 = @0xA;
// Begins a multi-transaction scenario with addr1 as the sender
let mut scenario = test_scenario::begin(addr1);
...
// Cleans up the scenario object
scenario.end();
```

--------------------------------

### List Widget Item on Marketplace

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/5_deployment_and_testing.md

Lists the minted widget item on the marketplace. This command requires the marketplace ID, item ID, listing price, and type arguments for the item and payment coin.

```bash
sui client call --function list --module marketplace --package $PACKAGE_ID --args $MARKET_ID $ITEM_ID 1 --type-args $PACKAGE_ID::widget::Widget 0x2::sui::SUI
```

--------------------------------

### Create and Deploy a Sui Move Package

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Scaffold, build, and publish a Move package to the Sui network. The package manifest (Move.toml) defines package metadata and dependencies.

```bash
# Create a new package skeleton
sui move new hello_world
```

```bash
# Resulting structure:
# hello_world/
#   Move.toml         <<- manifest
#   sources/          <<- contract source files
#   tests/            <<- test-only code (not published on-chain)
```

```toml
# Move.toml — package manifest
[package]
name = "hello_world"
edition = "2024.beta"

[dependencies]
# Sui system packages (std, sui, etc.) are auto-added since CLI v1.45

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

```bash
# Publish to the active network
sui client publish

# Call an entry function after deployment
export PACKAGE_ID=<package object ID from publish output>
sui client call --function mint --module hello_world --package $PACKAGE_ID
```

--------------------------------

### Define Empty Move Module

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/3_custom_types_and_abilities.md

Creates an empty Move module named 'hello_world' within the 'hello_world' package.

```move
module hello_world::hello_world;
// module contents
```

--------------------------------

### Parameter Passing in Move

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Demonstrates how to pass parameters by immutable reference (`&`), mutable reference (`&mut`), and by value (ownership transfer). Use `view_score` for read-only access, `update_score` for modification, and `delete_transcript` to consume and destroy an object.

```move
// Read-only: borrow immutably
public fun view_score(transcript_object: &TranscriptObject): u8 {
    transcript_object.literature
}

// Modify: borrow mutably
public fun update_score(transcript_object: &mut TranscriptObject, score: u8) {
    transcript_object.literature = score
}

// Consume + delete: take ownership and unpack
public fun delete_transcript(transcript_object: TranscriptObject) {
    // Structs must be unpacked in their defining module before the UID can be deleted
    let TranscriptObject { id, .. } = transcript_object;
    id.delete();
}
```

--------------------------------

### create_currency Method

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/4_the_coin_resource_and_create_currency.md

Creates a new custom fungible token currency. It requires a one-time witness, metadata like decimals and symbol, and a transaction context. It returns a TreasuryCap for minting/burning and CoinMetadata for display.

```move
public fun create_currency<T: drop>(
    witness: T,
    decimals: u8,
    symbol: vector<u8>,
    name: vector<u8>,
    description: vector<u8>,
    icon_url: Option<Url>,
    ctx: &mut TxContext,
): (TreasuryCap<T>, CoinMetadata<T>) {
    // Make sure there's only one instance of the type T
    assert!(sui::types::is_one_time_witness(&witness), EBadWitness);

    (
        TreasuryCap {
            id: object::new(ctx),
            total_supply: balance::create_supply(witness),
        },
        CoinMetadata {
            id: object::new(ctx),
            decimals,
            name: string::utf8(name),
            symbol: ascii::string(symbol),
            description: string::utf8(description),
            icon_url,
        },
    )
}
```

--------------------------------

### Define Test Module and Basic Test Function

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/7_unit_testing.md

Use #[test_only] to define a module for test code and #[test] to mark functions as executable tests. Do not prefix test function names with 'test_'.

```move
#[test_only]
module fungible_tokens::managed_tests;

#[test]
fun mint_burn() {
}
```

--------------------------------

### Assert Macro Usage

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-two/lessons/5_object_wrapping_example.md

Illustrates the syntax for the assert macro, which takes a boolean expression and an error code to abort execution if the condition is false.

```move
assert!(<bool expression>, <code>)
```

--------------------------------

### Create Generic Marketplace Contract in Move

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Defines a generic marketplace that supports arbitrary item types and any fungible token for payment. It includes structures for the Marketplace itself, individual Listings, and helper keys.

```move
module marketplace::marketplace;

use sui::bag::{Self, Bag};
use sui::table::{Self, Table};
use sui::coin::{Self, Coin};
use sui::dynamic_object_field as dof;

public struct Marketplace<phantom COIN> has key {
    id: UID,
    items: Bag,                             // heterogeneous item listings
    payments: Table<address, Coin<COIN>>,   // per-seller accumulated payments
}

public struct Listing has key, store {
    id: UID,
    ask: u64,
    owner: address,
}
public struct ListingItemKey() has copy, drop, store;

/// Create a new shared Marketplace
public fun create<COIN>(ctx: &mut TxContext) {
    transfer::share_object(Marketplace<COIN> {
        id: object::new(ctx),
        items: bag::new(ctx),
        payments: table::new(ctx),
    });
}

/// List any item T for sale
public fun list<T: key + store, COIN>(
    marketplace: &mut Marketplace<COIN>,
    item: T,
    ask: u64,
    ctx: &mut TxContext,
) {
    let item_id = object::id(&item);
    let mut listing = Listing { id: object::new(ctx), ask, owner: ctx.sender() };
    dof::add(&mut listing.id, ListingItemKey(), item);
    marketplace.items.add(item_id, listing)
}

/// Buy a listed item; payment must match the ask price exactly
public fun buy_and_take<T: key + store, COIN>(
    marketplace: &mut Marketplace<COIN>,
    item_id: ID,
    paid: Coin<COIN>,
    ctx: &mut TxContext,
) {
    let Listing { mut id, ask, owner } = marketplace.items.remove(item_id);
    assert!(ask == paid.value(), 0 // EAmountIncorrect
    );
    if (marketplace.payments.contains(owner)) {
        marketplace.payments.borrow_mut(owner).join(paid)
    } else {
        marketplace.payments.add(owner, paid)
    };
    let item: T = dof::remove(&mut id, ListingItemKey());
    id.delete();
    transfer::public_transfer(item, ctx.sender())
}

/// Seller withdraws accumulated payment
public fun take_profits_and_keep<COIN>(
    marketplace: &mut Marketplace<COIN>,
    ctx: &mut TxContext,
) {
    let profits = marketplace.payments.remove(ctx.sender());
    transfer::public_transfer(profits, ctx.sender())
}

```

--------------------------------

### Creating a Custom Fungible Token with Coin::create_currency

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Uses 'coin::create_currency' with a One Time Witness 'MANAGED' to define a custom fungible token. Provides mint and burn functions for token management.

```move
module fungible_tokens::managed;

use sui::coin::{Self, Coin, TreasuryCap};

/// OTW — must match module name in ALL_CAPS, only `drop` ability
public struct MANAGED has drop {}

fun init(witness: MANAGED, ctx: &mut TxContext) {
    let (treasury_cap, metadata) = coin::create_currency<MANAGED>(
        witness,
        2,                        // decimals
        b"MNG",                   // symbol
        b"Managed Coin",          // name
        b"A managed coin example",// description
        option::none(),           // icon URL
        ctx,
    );
    // Freeze metadata so anyone can read it; keep TreasuryCap for mint/burn control
    transfer::public_freeze_object(metadata);
    transfer::public_transfer(treasury_cap, ctx.sender())
}

public fun mint(
    treasury_cap: &mut TreasuryCap<MANAGED>,
    amount: u64,
    recipient: address,
    ctx: &mut TxContext,
) {
    treasury_cap.mint_and_transfer(amount, recipient, ctx)
}

public fun burn(treasury_cap: &mut TreasuryCap<MANAGED>, coin: Coin<MANAGED>) {
    treasury_cap.burn(coin);
}
```

```bash
# Deploy
sui client publish
export PACKAGE_ID=<package object ID>
export TREASURYCAP_ID=<TreasuryCap object ID>

# Mint 100 tokens to a recipient
sui client call \
  --function mint --module managed --package $PACKAGE_ID \
  --args $TREASURYCAP_ID 100 <recipient address>

export COIN_ID=<minted Coin object ID>

# Burn the coin
sui client call \
  --function burn --module managed --package $PACKAGE_ID \
  --args $TREASURYCAP_ID $COIN_ID
```

--------------------------------

### Define Custom Types and Entry Functions in Move

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Declare Move structs with abilities and write an entry function that mints and transfers an object. Types with `key + store` are assets transferable between addresses.

```move
module hello_world::hello_world;

use std::string;

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

/// Entry function: called directly by a transaction, no return value.
entry fun mint(ctx: &mut TxContext) {
    let object = HelloWorldObject {
        id: object::new(ctx),
        text: b"Hello World!".to_string(),
    };
    transfer::public_transfer(object, ctx.sender());
}
```

--------------------------------

### Run Sui Move Unit Tests

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/advanced-topics/BCS_encoding/lessons/BCS_encoding.md

Execute the Move unit tests for the project to verify the correctness of the BCS encoding and decoding logic.

```bash
sui move test
```

--------------------------------

### Publish Package using SUI CLI

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/5_deployment_and_testing.md

Publishes your Move package to the Sui network. Ensure your package is correctly structured before running this command.

```bash
sui client publish
```

--------------------------------

### Define Marketplace Widget Module

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/5_deployment_and_testing.md

Defines a simple widget module for creating items to be listed on the marketplace. This module includes a struct for the widget and a mint function.

```move
module marketplace::widget;

public struct Widget has key, store {
    id: UID,
}

#[lint_allow(self_transfer)]
public fun mint(ctx: &mut TxContext) {
    let obj = Widget {
        id: object::new(ctx),
    };
    transfer::public_transfer(obj, ctx.sender());
}
```

--------------------------------

### Request Transcript Method

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-two/lessons/5_object_wrapping_example.md

Wraps a WrappableTranscript in a Folder object and transfers it to the specified intended address. Requires a TxContext.

```move
public fun request_transcript(transcript: WrappableTranscript, intended_address: address, ctx: &mut TxContext){
    let folder_object = Folder {
        id: object::new(ctx),
        transcript,
        intended_address
    };
    //We transfer the wrapped transcript object directly to the intended address
    transfer::transfer(folder_object, intended_address)
}
```

--------------------------------

### List Sui Gas Objects

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Display all controlled gas objects associated with the current Sui CLI configuration.

```bash
sui client gas
```

--------------------------------

### Call new_policy function

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/5_transfer_policy.md

This command-line instruction calls the `new_policy` function to create a TransferPolicy. Ensure the KIOSK_PACKAGE_ID and KIOSK_PUBLISHER environment variables are set.

```bash
sui client call --package $KIOSK_PACKAGE_ID --module kiosk --function new_policy --args $KIOSK_PUBLISHER
```

--------------------------------

### Mint a Widget Item

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/5_deployment_and_testing.md

Mints a new widget item using the `mint` function from the `widget` module. This item can then be listed on the marketplace.

```bash
sui client call --function mint --module widget --package $PACKAGE_ID
```

--------------------------------

### Initialize Module for Testing

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Initializes the `managed` module state specifically for testing purposes. This function is marked with `#[test_only]` and should only be used within test scenarios.

```move
@#[test_only]
module fungible_tokens::managed_tests;

use sui::test_scenario;
use fungible_tokens::managed::{Self, MANAGED, TreasuryCap};

#[test_only]
public fun test_init(ctx: &mut TxContext) {
    managed::init_for_testing(MANAGED {}, ctx)
}
```

--------------------------------

### Borrow from LoanPool in Move

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/2_hot_potato_pattern.md

Allows users to borrow a specified amount from the `LoanPool`. It returns the borrowed `Coin<SUI>` and a `Loan` struct, which acts as a hot potato that must be repaid.

```move
/// Function allows users to borrow from the loan pool.
/// It returns the borrowed [`Coin<SUI>`] and the [`Loan`] position
/// enforcing users to fulfill before the PTB ends.
public fun borrow(
    pool: &mut LoanPool,
    amount: u64,
    ctx: &mut TxContext,
): (Coin<SUI>, Loan) {
    assert!(amount <= pool.amount.value(), ELoanAmountExceedPool);
    (
        pool.amount.split(amount).into_coin(ctx),
        Loan {
            amount,
        },
    )
}
```

--------------------------------

### Create, Share, and Freeze Sui Objects

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Defines a TranscriptObject and provides functions to create it, make it shared and mutable, or freeze it as immutable. Use `create_transcript_object` to create an owned object, `share_transcript` to make it globally accessible and mutable, and `freeze_transcript` to make it permanently immutable.

```move
module transcript::transcript;

public struct TranscriptObject has key {
    id: UID,
    history: u8,
    math: u8,
    literature: u8,
}

// Owned by the transaction sender
public fun create_transcript_object(
    history: u8, math: u8, literature: u8, ctx: &mut TxContext
) {
    let transcript_object = TranscriptObject {
        id: object::new(ctx),
        history,
        math,
        literature,
    };
    transfer::transfer(transcript_object, ctx.sender())
}

// Make permanently immutable — readable by anyone, unmodifiable
public fun freeze_transcript(transcript: TranscriptObject) {
    transfer::freeze_object(transcript);
}

// Make a shared mutable object — accessible and mutable by anyone
public fun share_transcript(transcript: TranscriptObject) {
    transfer::share_object(transcript);
}
```

--------------------------------

### Sui CLI Command for Running Unit Tests

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Command to execute all unit tests defined within the Sui Move package. It will output the status of each test, indicating whether it passed or failed.

```bash
# Run all unit tests in the package
sui move test
# Expected output:
# [ PASS ] fungible_tokens::managed_tests::mint_burn
# Test result: OK. Total tests: 1; passed: 1; failed: 0
```

--------------------------------

### Connect to Local Sui Devnet

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/5_contract_deployment.md

When using a local development node, configure Sui Explorer to connect to the custom RPC URL.

```bash
http://127.0.0.1:9000
```

--------------------------------

### Unit Test for Minting and Burning Tokens

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

A unit test using `test_scenario` to verify the minting functionality of the `managed` module. It initializes the module, then mints tokens to a specified address. This test requires the `managed` module to be initialized first.

```move
@#[test]
fun mint_burn() {
    let addr1 = @0xA;
    let mut scenario = test_scenario::begin(addr1);

    // Initialize module state
    { managed::test_init(scenario.ctx()) };

    // Mint tokens in next transaction
    scenario.next_tx(addr1);
    {
        let mut treasury_cap = scenario.take_from_sender<TreasuryCap<MANAGED>>();
        managed::mint(&mut treasury_cap, 100, addr1, scenario.ctx());
        test_scenario::return_to_address(addr1, treasury_cap);
    };

    scenario.end();
}
```

--------------------------------

### Test-Only Module Initializer

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/7_unit_testing.md

Create a test-specific initializer function within your module to set up the initial state for tests. This function is marked with #[test_only].

```move
#[test_only]
/// Wrapper of module initializer for testing
public fun test_init(ctx: &mut TxContext) {
    init(MANAGED {}, ctx)
}
```

--------------------------------

### Emitting Custom On-Chain Events

Source: https://context7.com/sui-foundation/sui-move-intro-course/llms.txt

Defines a `TranscriptRequested` event struct with `copy` and `drop` abilities, and demonstrates how to emit this event within the `request_transcript` function. This allows indexers and explorers to track specific on-chain activities.

```move
use sui::event;

/// Event type: needs `copy` and `drop` abilities (not assets)
public struct TranscriptRequested has copy, drop {
    wrapper_id: ID,
    requester: address,
    intended_address: address,
}

public fun request_transcript(
    transcript: WrappableTranscript,
    intended_address: address,
    ctx: &mut TxContext,
) {
    let folder_object = Folder {
        id: object::new(ctx),
        transcript,
        intended_address,
    };
    // Emit the event — visible on Sui Explorer under the Events tab
    event::emit(TranscriptRequested {
        wrapper_id: object::id(&folder_object),
        requester: ctx.sender(),
        intended_address,
    });
    transfer::transfer(folder_object, intended_address);
}
```

--------------------------------

### BCS Type Registration with Transforms in JavaScript

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/advanced-topics/BCS_encoding/lessons/BCS_encoding.md

Shows how to register custom types like an Address (as a 32-byte array) and a struct with nested types. Includes transforms for converting hex strings to Uint8Arrays and vice-versa.

```javascript
import { bcs, fromHex, toHex } from "@mysten/bcs";

// Define Address as a 32-byte array, then add a transform to/from hex strings
const Address = bcs.fixedArray(32, bcs.u8()).transform({
  input: (id) => fromHex(id),
  output: (id) => toHex(Uint8Array.from(id)),
});

// Register the struct types
const bcsStruct = bcs.struct("BCSObject", {
  id: Address,
  owner: Address,
  meta: bcs.struct("Metadata", {
    name: bcs.string(),
  }),
});
```

--------------------------------

### Define a Public Addition Function in Move

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/4_functions.md

This function demonstrates how to define a public function that takes two u8 arguments and returns their sum as a u8. The last expression without a semicolon is the return value.

```move
public fun addition (a: u8, b: u8): u8 {
    a + b
}
```

--------------------------------

### Define LoanPool and Loan Structs in Move

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-five/lessons/2_hot_potato_pattern.md

Defines the `LoanPool` shared object and the `Loan` hot potato struct. The `Loan` struct has no abilities, enforcing its consumption within the same module.

```move
module flashloan::flashloan;

// === Imports ===
use sui::balance::{Self, Balance};
use sui::coin::{Self, Coin};
use sui::object::{Self, UID};
use sui::sui::SUI;

/// For when the loan amount exceed the pool amount
const ELoanAmountExceedPool: u64 = 0;
/// For when the repay amount do not match the initial loan amount
const ERepayAmountInvalid: u64 = 1;

/// A "shared" loan pool.
/// For demonstration purpose, we assume the loan pool only allows SUI.
public struct LoanPool has key {
    id: UID,
    amount: Balance<SUI>,
}

/// A loan position (hot potato: no abilities).
/// Enforces users to repay the loan before the transaction or PTB ends.
/// Do not use a "Potato" suffix — the lack of abilities already signals a hot potato.
public struct Loan {
    amount: u64,
}
```

--------------------------------

### Add New Sui Network Alias

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

Add a new network alias and its corresponding RPC URL to the Sui CLI configuration.

```bash
sui client new-env --alias <ALIAS> --rpc <RPC>
```

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

--------------------------------

### Check Sui Addresses

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-one/lessons/1_set_up_environment.md

View the addresses currently stored in the Sui CLI key store and check the active address.

```bash
sui client addresses
```

```bash
sui client active-address
```

--------------------------------

### Call generic functions using Sui CLI

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/2_intro_to_generics.md

To call a generic function from the Sui CLI, use the --type-args flag to specify the generic type.

```bash
sui client call --package $PACKAGE --module $MODULE --function "create_box" --args $OBJECT_ID --type-args 0x2::sui::SUI
```

--------------------------------

### Define Marketplace Struct

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/4_marketplace_contract.md

Defines the main Marketplace struct, including its ID, a Bag for item listings, and a Table for payment tracking. It is generic over the COIN type accepted for payments.

```move
/// A shared `Marketplace`. Can be created by anyone using the
/// `create` function. One instance of `Marketplace` accepts
/// only one type of Coin - `COIN` for all its listings.
public struct Marketplace<phantom COIN> has key {
    id: UID,
    items: Bag,
    payments: Table<address, Coin<COIN>>
}
```

--------------------------------

### Call Sui Client to Emit Object

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/advanced-topics/BCS_encoding/lessons/BCS_encoding.md

Publish the Move module and call the `emit_object` method using the previously exported BCS serialized hexstring. This demonstrates emitting a deserialized object on the Sui network.

```bash
sui client call --function emit_object --module bcs_object --package $PACKAGE_ID --args $OBJECT_HEXSTRING
```

--------------------------------

### List Item Function

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-four/lessons/4_marketplace_contract.md

Allows a user to list an item on the marketplace. It creates a Listing object, attaches the item using a dynamic object field, and adds the listing to the marketplace's items Bag.

```move
/// List an item at the Marketplace.
public fun list<T: key + store, COIN>(
    mut marketplace: &mut Marketplace<COIN>,
    item: T,
    ask: u64,
    ctx: &mut TxContext,
) {
    let item_id = object::id(&item);
    let mut listing = Listing {
        id: object::new(ctx),
        ask,
        owner: ctx.sender(),
    };

    dof::add(&mut listing.id, ListingItemKey(), item);
    marketplace.items.add(item_id, listing)
}
```

--------------------------------

### Create a generic Box creation function in Move

Source: https://github.com/sui-foundation/sui-move-intro-course/blob/main/unit-three/lessons/2_intro_to_generics.md

Define a function that creates instances of a generic struct. The function signature must include the generic type parameter and its constraints.

```move
public fun create_box<T: store>(value: T, ctx: &mut TxContext): Box<T> {
    Box<T> { id: object::new(ctx), value }
}
```

```move
public fun create_box(value: u64, ctx: &mut TxContext): Box<u64> {
    Box<u64> { id: object::new(ctx), value }
}
```
Tokens:
Raw