Sui Move：基本概览一

Module (模块)

Move 代码被组织成模块, 可以把一个模块看成是区块链上的一个智能合约
可以通过调用这些模块中的函数来与模块进行交互，可以通过事务或其他 Move 代码来实现, 事务将被发送到并由Sui区块链进行处理，一旦执行完成，结果的更改将被保存
一个模块由 module 关键字 + 地址 + 模块名组成, 其中地址可以写成 alias (定义在 Move.toml中), 例如 lets_move_sui
```
module lets_move_sui::sui_fren {}
```

基本数据类型

无符号整数: u8, u16, u32, u64, u128, u256
Boolean: bool
Addresses: address
字符串: String
Vector: vector, 例如 vector<u64>
自定义的结构体类型, 例如下面定义的 Struct

Struct (结构体)

结构体是 Sui Move 中的一个基本概念
结构体可以看成是一组相关字段的组合, 每个字段都有自己的类型
Sui Move 可以为结构体添加4 种能力: key、store、drop、copy, 这些能力后续会慢慢涉及
下面是一个基本的结构体名为 AdminCap, 内部含有一个 num_frens字段
```
    public struct AdminCap {num_frens: u64,}
```

添加一个私有函数 init, 这是一个特殊的函数, 会在 module 部署到区块链时, 自动调用

    fun init(ctx: &mut TxContext) {let admin_cap = AdminCap {id: object::new(ctx),num_frens: 1000,};transfer::share_object(admin_cap);}

Object

Object 是 Sui 中的一个基本概念
在 Sui 中, 所有数据可以视为不同 Object 内部的字段
使用结构体(Struct)来表示Object
可以根据 module 中定义的函数进行创建, 读取, 修改,交互 Object

创建一个 Object

一个 Object 一般都有 key 能力以及含有一个类型为 UID 的 id 字段
- sui::object::new : 创建一个新对象。返回必须存储在 Sui 对象中的 UID
```
    public fun new(ctx: &mut TxContext): UID {UID {id: ID { bytes: tx_context::fresh_object_address(ctx) },}}
```
创建 Ticket: create_ticket

示例代码

module lets_move_sui::ticket_module {use sui::clock::{Self, Clock};use sui::object::{Self, ID, UID};use sui::transfer;use sui::tx_context::{Self, TxContext};public struct Ticket has key {id: UID,}public fun create_ticket(ctx: &mut TxContext, clock: &Clock) {let uid = object::new(ctx);let ticket = Ticket {id: uid,expiration_time: clock::timestamp_ms(clock),};transfer::transfer(ticket, tx_context::sender(ctx));}
}

读取 Ojbect 中的字段

一个 Ticket 一般都有过期时间
- 在 Ticket 结构体中添加一个 expiration_time 字段
- 在 ticket_module 中添加一个 is_expired 方法来检测是否过期

module lets_move_sui::ticket_module {use sui::clock::{Self, Clock};use sui::object::{Self, ID, UID};use sui::transfer;use sui::tx_context::{Self, TxContext};public struct Ticket has key {id: UID,expiration_time: u64,}public fun create_ticket(ctx: &mut TxContext, clock: &Clock) {let uid = object::new(ctx);let ticket = Ticket {id: uid,expiration_time: clock::timestamp_ms(clock),};transfer::transfer(ticket, tx_context::sender(ctx));}public fun is_expired(ticket: &Ticket, clock: &Clock): bool {ticket.expiration_time <= clock::timestamp_ms(clock)}
}

修改 Object 中的字段

需要在函数中传入一个可变引用

module 0x123::my_module {use std::vector;use sui::object::{Self, UID};use sui::transfer;use sui::tx_context::TxContext;struct MyObject has key {id: UID,value: u64,}fun init(ctx: &mut TxContext) {let my_object = MyObject {id: object::new(ctx),value: 10,};transfer::share_object(my_object);}public fun set_value(global_data: &mut MyObject, value: u64) {global_data.value = value;}
}

删除一个 Object

sui::object::delete : 删除该对象及其 UID 。这是消除 UID 的唯一方法

    public fun delete(id: UID) {let UID { id: ID { bytes } } = id;delete_impl(bytes)}

示例代码

module 0x123::ticket_module {use sui::clock::{Self, Clock};use sui::object::{Self, UID};use sui::transfer;use sui::tx_context::TxContext;struct Ticket has key {id: UID,expiration_time: u64,}public fun clip_ticket(ticket: Ticket) {let Ticket {id,expiration_time: _,} = ticket;object::delete(id);}
}

Math

在 Move 中数学运算和其他编程语言非常相似
需要注意的是 x^y 表示以 x 为底, 指数为 y

类型转换

相同的类型可以直接进行算术运算, 但是不同的类型之间想要进行算术运算, 则需要进行转换

在 Move 中类型转换可以使用这种形式: (x as <type>), 例如(x as u64)

fun mixed_types_math_error(): u64 {let x: u8 = 1;let y: u64 = 2;// This will fail to compile as x and y are different types. One is u8, the other is u64.x + y
}fun mixed_types_math_ok(): u64 {let x: u8 = 1;let y: u64 = 2;// Ok(x as u64) + y
}

Vector

vector 相当于是一个动态数组, 这是 Move 内置的一个数据结构, 后续会了解到更多

创建 vector

   // The empty vector does not yet have a type declared. The first value added will determine its type.let empty_vector = vector[];let int_vector = vector[1, 2, 3];let bool_vector = vector[true, true, false];

vector in struct field

   struct MyObject has key {id: UID,values: vector<u64>,bool_values: vector<bool>,address_values: vector<address>,}

Public function and Private function

init 函数必须是 Private 的, 它会在合约部署的时候由 Sui 虚拟机(VM)调用
Public 意味着它可以被任何其他的 Move module 和 transactions 调用
Private 意味着只能被当前 Move module 调用, 并且不能从 transaction 中调用

module lets_move_sui::sui_fren {use sui::tx_context::{Self, TxContext};use sui::transfer;use sui::object::{Self, ID, UID};use std::string::String;// use std::vector; // built-inuse sui::event;public struct AdminCap has key {id: UID,num_frens: u64,}public struct SuiFren has key {id: UID,generation: u64,birthdate: u64,attributes: vector<String>,}fun init(ctx: &mut TxContext) {let admin_cap = AdminCap {id: object::new(ctx),num_frens: 10^3, // 1000};transfer::share_object(admin_cap);}// change the mint function to transfer the object to the senderpublic fun mint(generation: u64, birthdate: u64, attributes: vector<String>, ctx: &mut TxContext) {let uid = object::new(ctx);let sui_fren = SuiFren {id: uid,generation,birthdate,attributes,};transfer::transfer(sui_fren, tx_context::sender(ctx));}public fun burn(sui_fren: SuiFren) {let SuiFren {id,generation: _,birthdate: _,attributes: _,} = sui_fren;object::delete(id);}public fun get_attributes(sui_fren: &SuiFren): vector<String> {sui_fren.attributes}public fun update_attributes(sui_fren: &mut SuiFren, attributes: vector<String>) {sui_fren.attributes = attributes;}
}

Shared Object and Owned Object

Shared Objects 可以被任何用户读取和修改
- 不能并行处理(例如修改), 并且需要严格的检查, 性能慢, 可扩展性差
Owned Objects 是私有对象，只有拥有它们的用户才能读取和修改(所有权)
- 只允许直接所有权，因此如果用户A拥有对象B，而对象B拥有对象C，则用户A无法发送包含对象C的事务, 这个问题可以使用 Receiving<T> 解决(后续会提及)
- 可以并行处理, 因为涉及它们的 transaction (事务) 不会相互重叠
sui::transfer::share_object : 将给定的对象转换为一个可变的共享对象，每个人都可以访问和修改
```
public fun share_object<T: key>(obj: T) {share_object_impl(obj)
}
```

sui::transfer::transfer : 将 obj 的所有权转移给接收者。obj 必须具有 key 属性

public fun transfer<T: key>(obj: T, recipient: address) {transfer_impl(obj, recipient)
}

示例代码

module lets_move_sui::shared_and_owned {use sui::object::{Self, UID};use sui::tx_context::{Self, TxContext};use sui::transfer;public struct SharedObject has key {id: UID,}public struct OwnedObject has key {id: UID,}public fun create_shared_object(ctx: &mut TxContext) {let shared_object = SharedObject {id: object::new(ctx),};transfer::share_object(shared_object);}public fun create_owned_object(ctx: &mut TxContext) {let owned_object = OwnedObject {id: object::new(ctx),};transfer::transfer(owned_object, tx_context::sender(ctx));}
}

Event (事件)

什么是 Event? Event 是你的module 将区块链上发生的事情传达给应用程序前端的一种方式
应用程序可以监听某些 Event 来采取行动
Event 主要用来给”链下”组件与 “链上”组件进行交互
sui::event::emit : 发出自定义的 Move Event，将数据发送到链下。由下面的函数签名可知, emit 的参数需要一个包含 copy 和 drop 能力的类型
```
public native fun emit<T: copy + drop>(event: T);
```

示例代码

module 0x123::ticket_module {use sui::clock::{Self, Clock};use sui::event;use sui::object::{Self, ID, UID};use sui::transfer;use sui::tx_context::{Self, TxContext};struct Ticket has key {id: UID,expiration_time: u64,}struct CreateTicketEvent has copy, drop {id: ID,}struct ClipTicketEvent has copy, drop {id: ID,}public fun create_ticket(ctx: &mut TxContext, clock: &Clock) {let uid = object::new(ctx);let id = object::uid_to_inner(&uid);let ticket = Ticket {id: uid,expiration_time: clock::timestamp_ms(clock),};transfer::transfer(ticket, tx_context::sender(ctx));event::emit(CreateTicketEvent {id,});}public fun clip_ticket(ticket: Ticket) {let Ticket { id, expiration_time: _ } = ticket;object::delete(id);event::emit(ClipTicketEvent {id: object::uid_to_inner(&id),});}
}