1. 区块链平台：区块链平台是一个分布式数据库，，它由许多计算机节点组成。这些计算机节点共同维护着一个共享的账本，称为区块链。（比如sui）
2. 智能合约： 运行在区块链平台上的计算机程序，智能合约主要执行3件事：创建资产，管理资产，权限控制
3. move语言：智能合约编程语言，可以类比于c语言这种计算机编程语言

4. 区块链资产(Blockchain  Asset)：区块链网络上记录和存储的数字化资产，比如加密货币（比特币），稳定币（加密货币的一种，但和法定货币直接挂钩，如usdt），NFT（数字资产，艺术品），Coin代币（代表各种东西，如公司股票）
5. 区块链账户（Blockchain Account）：是在区块链网络中用于存储和管理用户资产和交易记录的数字账户。每个参与特定区块链网络的用户都可以拥有一个或多个区块链账户。（实际上就是公私钥对，公钥做地址，私钥做身份认证）
6. 资产所有权(Ownership)：资产所有权是指对资产的占有、使用、收益和处分的权利。
资产所有权可以分为以下几种类型：
独有权：私有权是指个人资产的专有所有权。
共有权：共有权是指两个人或两个人以上共同对资产的所有权。
7. 区块链钱包（Blockchain Wallet）：是一种用于存储、管理和交换加密货币的数字钱包。它是在区块链技术基础上开发的工具，允许用户安全地保存其加密货币资产（包括生成区块链账号），并进行交易和管理。
区块链钱包的类型有很多，包括：
热钱包：热钱包是指连接互联网的区块链钱包。热钱包比较方便使用，但安全性较低。
冷钱包：冷钱包是指不连接互联网的区块链钱包。冷钱包比较安全，但使用起来不太方便。
硬件钱包：硬件钱包是一种物理设备，它可以用来存储和管理区块链资产。硬件钱包非常安全，但价格比较昂贵。
8. 区块链浏览器（Blockchain Explorer）：一种用于浏览和查询区块链上数据的工具。它提供了一种用户友好的界面，使用户能够浏览区块链上的交易、区块、地址和其他相关信息。

# 下载安装脚本
git clone --depth=1 https://mirrors.tuna.tsinghua.edu.cn/git/homebrew/install.git brew-install

# 执行安装脚本
./brew-install/install.sh

# 将brew添加到环境变量，路径为/home/your_user/.bashrc
echo >> /home/wsxk/.bashrc
echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"' >> /home/wsxk/.bashrc
eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"

# 用brew安装sui
brew install sui

sudo apt-get install curl git-all cmake gcc libssl-dev pkg-config libclang-dev libpq-dev build-essential
sudo snap install rustup --classic
rustup default stable
cargo install --git https://github.com/MystenLabs/sui.git sui-move-lsp

sui client publish //发布上链
sui client call --package package_id --module module_name --function func_name --args .... 
//如果参数中需要用到地址，需要记住参数的object id

#[test]
public fun test_a_greater_than_b() {
  debug::print(&string::utf8(b"test start!"));
}

1. fun call():                 表示只有module内可见，只能在module内被调用
2. public(package) fun call(): 表示只对当前package内可见，可以在package内被调用
3. public fun call():          表示对任意package可见，其他package都可以调用,包括 sui client call
4. entry fun call():           表示能被链下其他事务调用（即dapp(RPC)调用）
5. public entry fun call():    表示任意package，链下其他事务都能调用。

//寻常struct
public struct NAME {
    FIELD1: TYPE1,
    FIELD2: TYPE2,
    ...
}
//每个struct最多有4个能力
//key：在全局存储操作中值可以被用为key键
//store：值可以在全局存储中被存储
//copy：值可以被复制
//drop：作用域范围结束后可以被丢弃

//object，加个 has key，且结构体的第一个成员变量一定是UID类型，就会变成object（对象），move中这种object就代表一个资产。
public  struct ColorObject has key {
        id: UID,
        red: u8,
        green: u8,
        blue: u8,
}

1. 对于只有key属性的独享所有权对象，要进行所有权转移，需要使用transfer方法
2. 对于有key+store属性的独享所有权对象，要进行所有权转移，需要使用public_transfer方法
3. 对于只有key的共享所有权对象，在使用时必须进行share_object方法来设置对象
4. 对于有key+store的共享所有权对象，在使用时必须进行public_share_object来设置对象

fun f(consume: T, write: &mut T, read: &T)
T: transfer, delete, write, read  //这种场景下相当于访问权限从父函数传递到了f函数，父函数之后不能再使用，除非f函数又将T返回
&mut T: write, read //父函数还是拥有先前权限
&T: read//父函数还是拥有先前权限

// Type that marks the capability to create, update, and delete transcripts
public struct TeacherCap has key {
  id: UID
}

//只有拥有TeacherCap能力的调用者，才能完成调用
public entry fun create_wrappable_transcript_object(_: &TeacherCap, history: u8, math: u8, literature: u8, ctx: &mut TxContext) {
  let wrappableTranscript = WrappableTranscript {
      id: object::new(ctx),
      history,
      math,
      literature,
  };
  transfer::transfer(wrappableTranscript, tx_context::sender(ctx))
}

/// Module that defines a generic type `Guardian<T>` which can only be
/// instantiated with a witness.
module witness::peace {
  use sui::object::{Self, UID};
  use sui::transfer;
  use sui::tx_context::{Self, TxContext};

  /// 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.
  struct PEACE has drop {}//这就是witness变量，witness必须有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>( //witness虽然没有被用到变量当中，但是却表示了这个结构体是唯一的。
      _witness: 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::transfer(
          create_guardian(witness, ctx),
          tx_context::sender(ctx)
      )
  }
}

public struct Coin<phantom T> has key, store {
        id: UID,
        balance: Balance<T>
    }
public struct Balance<phantom T> has store {
    value: u64
}

    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, OTW模式
        assert!(sui::types::is_one_time_witness(&witness), EBadWitness);

        // Emit Currency metadata as an event.
        event::emit(CurrencyCreated<T> {
            decimals
        });

        (
            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
            }
        )
    }

    /// Capability allowing the bearer to mint and burn
    /// coins of type `T`. Transferable
public struct TreasuryCap<phantom T> has key, store {
            id: UID,
            total_supply: Supply<T>
        }
/// A Supply of T. Used for minting and burning.
    /// Wrapped into a `TreasuryCap` in the `Coin` module.
struct Supply<phantom T> has store {
        value: u64
    }

module collection::vector {

    use std::vector;

    public struct Widget {
    }

    // 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 hold 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>(vec: &mut GenericVector<T>, value: T) {
        vector::push_back<T>(&mut vec.values, value);
    }

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

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

module collection::table {
    use sui::table::{Table, Self};
    use sui::tx_context::{TxContext};

    // Defining a table with specified types for the key and value
    public struct IntegerTable {
        table_values: Table<u8, u8>
    }

    // Defining a table with generic types for the key and value 
    public struct GenericTable<phantom K: copy + drop + store, phantom V: store> {
        table_values: Table<K, V>
    }

    // Create a new, empty GenericTable with key type K, and value type V
    public fun create<K: copy + drop + store, V: store>(ctx: &mut TxContext): GenericTable<K, V> {
        GenericTable<K, V> {
            table_values: table::new<K, V>(ctx)
        }
    }

    // Adds a key-value pair to GenericTable
    public fun add<K: copy + drop + store, V: store>(table: &mut GenericTable<K, V>, k: K, v: V) {
        table::add(&mut table.table_values, k, v);
    }

    /// Removes the key-value pair in the GenericTable `table: &mut Table<K, V>` and returns the value.   
    public fun remove<K: copy + drop + store, V: store>(table: &mut GenericTable<K, V>, k: K): V {
        table::remove(&mut table.table_values, k)
    }

    // Borrows an immutable reference to the value associated with the key in GenericTable
    public fun borrow<K: copy + drop + store, V: store>(table: &GenericTable<K, V>, k: K): &V {
        table::borrow(&table.table_values, k)
    }

    /// Borrows a mutable reference to the value associated with the key in GenericTable
    public fun borrow_mut<K: copy + drop + store, V: store>(table: &mut GenericTable<K, V>, k: K): &mut V {
        table::borrow_mut(&mut table.table_values, k)
    }

    /// Check if a value associated with the key exists in the GenericTable
    public fun contains<K: copy + drop + store, V: store>(table: &GenericTable<K, V>, k: K): bool {
        table::contains<K, V>(&table.table_values, k)
    }

    /// Returns the size of the GenericTable, the number of key-value pairs
    public fun length<K: copy + drop + store, V: store>(table: &GenericTable<K, V>): u64 {
        table::length(&table.table_values)
    }

}

module collection::bag {

    use sui::bag::{Bag, Self};
    use sui::tx_context::{TxContext};

    // Defining a table with generic types for the key and value 
    public struct GenericBag {
       items: Bag
    }

    // Create a new, empty GenericBag
    public fun create(ctx: &mut TxContext): GenericBag {
        GenericBag{
            items: bag::new(ctx)
        }
    }

    // Adds a key-value pair to GenericBag
    public fun add<K: copy + drop + store, V: store>(bag: &mut GenericBag, k: K, v: V) {
       bag::add(&mut bag.items, k, v);
    }

    /// Removes the key-value pair from the GenericBag with the provided key and returns the value.   
    public fun remove<K: copy + drop + store, V: store>(bag: &mut GenericBag, k: K): V {
        bag::remove(&mut bag.items, k)
    }

    // Borrows an immutable reference to the value associated with the key in GenericBag
    public fun borrow<K: copy + drop + store, V: store>(bag: &GenericBag, k: K): &V {
        bag::borrow(&bag.items, k)
    }

    /// Borrows a mutable reference to the value associated with the key in GenericBag
    public fun borrow_mut<K: copy + drop + store, V: store>(bag: &mut GenericBag, k: K): &mut V {
        bag::borrow_mut(&mut bag.items, k)
    }

    /// Check if a value associated with the key exists in the GenericBag
    public fun contains<K: copy + drop + store>(bag: &GenericBag, k: K): bool {
        bag::contains<K>(&bag.items, k)
    }

    /// Returns the size of the GenericBag, the number of key-value pairs
    public fun length(bag: &GenericBag): u64 {
        bag::length(&bag.items)
    }
}

struct Table<phantom K, phantom V> has key, store {
    id: UID,   // 相当于“主键”
    size: u64, // 只是计数
}

field::add(&mut table.id, k, v); // 在 table.id 这棵“父对象”下挂一条动态字段
table.size += 1;

1. 动态字段：可以存储任何具有store能力的值，但是存储在这种字段中的对象将被视为被包装过（例如一个带有key能力的全局对象被嵌套进另一个结构体中），无法通过其直接访问通过外部工具（浏览器、钱包等）访问存储的 ID。添加时使用的是 field::add(&mut parent.id, name, child);

2. 动态对象字段：值必须是 Sui 对象（具有 key 和 store 能力，以及 id: UID 作为第一个字段），但仍然可以通过它们的对象 ID 直接访问被附上。添加是使用的是  ofield::add(&mut parent.id, name, child);