sui move 的对象存储状态和能力(ability)
- jinglin
- 更新于 2024-11-14 16:01
- 阅读 180
Move对象的有4种能力(abliity)1.对象的几种存储状态:新建的对象，进入未曾存储状态，一个交易结束之后，对象要么被销毁，要么被存储到网络的链上存储。链上存储的对象，也可以借用引用参与交易运算运行态的对象，可以通过share或freeze编程共享对象。freeze
Move 对象的有4种能力(abliity)
1. 对象的几种存储状态:
-
新建的对象， 进入未曾存储状态，一个交易结束之后，对象要么被销毁，要么被存储到网络的链上存储。
-
链上存储的对象，也可以借用引用参与交易运算
-
运行态的对象，可以通过share或freeze 编程共享对象。freeze的对象是只读的。
-
链上存储对象，可以通过函数调用作为输入参数，移动成运行态，进入运行态之后，又可以重新进入析构或重新存到链上。
2. 对象具有的四种ability (能力)
这四种能力是：
-
copy- 允许复制具有此功能的类型的值。
- 当赋值或传参数时,会自动拷贝成新对象
- 如果没有实现copy能力, 赋值的时候,是对象被移动
-
drop- 允许跳出作用域自动删除
-
store- 允许具有此功能的类型的值存在于 链上中的值中。 存在sui 网络上的对象的字段
- 对于 Sui，控制对象内部可以存储哪些数据。 还控制哪些类型可以在其定义模块之外传
-
key-
允许类型用作存储的 “key”。表面上，这意味着该值可以是 存储中的顶级价值;换句话说，它不需要包含在另一个值中，以 在仓库里。
-
对于 Sui，用于表示对象。
-
2.1 如果有copy能力,赋值就是拷贝成一个新对象
-
上图中27行,c对象被拷贝到d,c和d指向的不是同一个对象,
-
28 行修改了d,但是c没有被修改
-
32行和33行中,c和d取值不同.
2.2 如果没有copy 能力,赋值就是移动对象
第111 行中出现编译错误,因为 c 指向的对象已经转移到了d
public struct NonCopyable {
value :u64,
}
#[test]
fun test_non_copy(){
let c = NonCopyable{ value:33};
let d =c ;
std::debug::print(&c); //此时c对象已经被移动给d
std::debug::print(&d);
// sui::test_utils::destroy(c);
sui::test_utils::destroy(d);
} 2.3 销毁 (drop)
2.3.1 离开作用域自动销毁,需要具有drop能力
public struct IgnoreMe has drop{
a:u32,
b:u32
}
#[test]
fun test_ignore(){
let im = IgnoreMe{a:3,b:4};
print(&im);
}上文定义的IgnoreMe 对象im 具有自动析构的能力has drop,在离开函数的作用域时候自动析构.
2.3.2 没有drop能力的对象需要主动析构或保存到链上
public struct NoDrop{ value :u64 }
#[test]
fun test_nodrop(){
let no_drop = NoDrop{ value :34};
print(&no_drop);
let NoDrop{ value: _ } = no_drop;
}这个例子 NoDrop类型没有drop能力,对象离开作用域,需要析构,或者将对象的所有权转移.
- 第8行是析构对象的代码
2.3.4 不能析构时,能转移所有权:
fun useNoDrop(o : NoDrop ) : NoDrop{
std::debug::print(&o);
o
}
#[test]
fun testUseNoDrop(){
let o = NoDrop{value :4};
let d = useNoDrop(o);
NoDrop{value:_} = d;
}- 第1行函数UseNoDrop获得了对象o
- 第3行,函数将N哦Drop对象o 返回出去,将所有权转移出去.
- 第10 行,显示代码析构这个NoDrop对象
2.3.5 独立存储在链上
对象独立存储在链上,必须具有key能力 has key
public struct Keyable has key{
id : UID,
}
#[test]
fun test_key(){
let mut ctx = tx_context ::dummy();
let k = Keyable{ id: object::new(&mut ctx)};
std::debug::print(&k);
transfer::transfer(k,ctx.sender());
}这个例子中Keyable是具有key能力的,可以通过transfer传递到sui网络上存储, 指定owner地址.
2.3.6 对象作为 共享对象存储在链上,需要具有key能力
2.3.7 对象作为一个对象的一部分存储,需要具有store能力
use std::string::String;
public struct Grandson has store{
name : String,
}
public struct Child has store{
name : String,
child : Grandson,
}
public struct Parent has key{
id: UID,
child: Child,
}
#[test]
fun test_store_child(){
let mut ctx = tx_context::dummy();
let foo = Parent {
id : object::new(&mut ctx),
child: Child {
name : b"one child".to_string(),
child: Grandson{
name : b"a grandson".to_string(),
},
}
};
std::debug::print(&foo);
transfer::freeze_object(foo);
}-
Parent是独立存储,具有key能力
-
Child 都是作为独立存储对象Parent的字段
-
Grandson 作为Child的字段存储在链上,
-
Child 和Grandson 都具有store能力
2.3.8 无ablity 对象就必须在module内提供方法去析构它
-
一个对象,没有任何ability ,就是hot potato
-
没有key 和store 无法保存在链上
-
没有drop 不会自动析构
-
只能在本模块析构, 因为外部模块无法直接访问struct的字段
-
下图中模块A, 需要使用模块B中的Foo 对象,使用完毕需要调用模块B 的析构方法
public struct Foo { value :u32 }
2.3.8.1 根据对象不能外部析构的特性,构造借贷模型
2.3.8.2 闪电贷的逻辑
- 定义闪电贷的出借方,在borrow的时候获得Coin和 Loan对象,
- 在repay的时候才能销毁Loan对象, 如果借出放不调用repay,无法销毁Loan对象,交易会回滚.
- replay的时候需要校验传入的coin 要多于borrow的coin, 多出来的部分作为回报.
- 下面是 贷方代码的例子
module book::loan;
//hot potato pattern
public struct Loan{
feedback: u64, //还钱数
}
public struct Coin has key,store{
id:UID,
amount:u64
}
//借出钱
public fun borrow(amount:u64,ctx:&mut TxContext) :(Coin,Loan){
let feedback = amount * 103 /100;
let c = Coin{ id: object::new(ctx),amount};
(c, Loan{feedback})
}
const ErrNotEnoughFeedback:u64 = 43;
const OWNER_ADDR :address = @0xafe36044ef56d22494bfe6231e78dd128f097693f2d974761ee4d649e61f5fa2;//todo
public fun repay(coin: Coin,loan:Loan){
assert!(coin.amount >= loan.feedback,ErrNotEnoughFeedback);
transfer::public_transfer(coin,OWNER_ADDR);
Loan{ feedback:_} = loan;
}
``` {.line-numbers}
下面是借方模块的代码,使用测试代码演示
```c++
#[test_only]
module book::test_loan;
use book::loan::Coin;
////todo 贷款后赚钱的业务逻辑,这里没有实现
fun earn_money(coin : Coin ) :Coin{
coin
}
#[test]
#[expected_failure(abort_code=book::loan::ErrNotEnoughFeedback)]
fun borrow_test(){
let mut ctx = tx_context::dummy();
let (coin,loan) = book::loan::borrow(233,&mut ctx);
let new_money = earn_money(coin);
book::loan::repay(new_money,loan);
//todo 赚钱了，可以把feedback-amount 的钱，存入自己钱包
}
2.3.10 key + store ability
目前其他模块存到链上的对象,都需要key+store能力
public fun public_transfer<T: key + store>(obj: T, recipient: address) {
transfer_impl(obj, recipient)
}
public fun public_freeze_object<T: key + store>(obj: T) {
freeze_object_impl(obj)
}
public fun public_share_object<T: key + store>(obj: T) {
share_object_impl(obj)
}
