手把手教你Wasm合约开发(C++篇)
放弃六月们
发表于 2023-1-9 00:14:24
108
0
0
一、Hello World
按照惯例,我们还是从一个 Hello world 开始
#include#include! w* Q" Q& D* q8 X
using namespace ontio;class hello:public contract {
public:
using contract::contract:9 p" [" U0 i# H6 o1 T l2 A
void sayHello(){2 \" `! E- L! d# H- @1 f, C- m
printf("hello world!");' T/ o8 V( \& _6 g( Q
}0 p! _/ w8 P B
};) F6 e% k% f" S* k" b$ ~) ~7 K
ONTIO_DISPATCH(hello, (sayHello));+ i) a4 E+ i- k! |
1.1 合约入口
Ontology Wasm CDT 编译器已经对入口和参数解析进行了封装,所以开发者不需要重新定义入口方法。接下来是定义合约的对外接口,这是智能合约对外提供服务的方法。, y5 W5 ~3 N5 p" @0 t
ONTIO_DISPATCH(hello, (sayHello));$ e$ Q, S% O, [$ r6 Z
在上面的例子中, 我们暂时只支持 sayHello 这个方法:: l! h; w+ v Q# p4 l1 Z: v
printf("hello world!");* ^; r* p2 ]2 l8 h \/ O/ u+ G
这个“Hello world!”会在节点的日志中以调试信息打印出来。在实际的应用中, printf 只能用作调试的目的, 一个实际的智能合约,需要实现更多更复杂的功能。% W3 B0 I+ e5 {; f
1.2 智能合约 API6 c5 N( W- i8 [# v6 T" G5 C
Ontology Wasm 提供如下 API 与区块链的底层进行交互:
二、红包合约0 }1 @% y7 n! J6 i; U
下面我们通过一个更加复杂的例子来演示如何通过这些 API 来开发一个完整的 Wasm 智能合约。0 K3 R: n9 v( B1 F. C/ J
很多情况下我们都会通过各种 App,如微信等聊天工具发红包。我们可以给朋友发送红包,也可以抢其他人发送的红包,收到的钱会记入到个人微信账户中。; `" m+ o4 ]6 P9 D9 V
类似于微信的流程,我们将尝试创建一个智能合约。用户使用该合约,可以发送 ONT,ONG 或者是标准的 OEP-4的 Token 资产红包给他的朋友们,而朋友们抢到的红包可以直接转入到他们的钱包账户中。
2.1 创建合约
首先,我们需要新建合约的源文件,暂且命名为 redEnvelope.cpp。这个合约我们需要三个接口:
createRedEnvelope: 创建红包6 F& g* T. v& i, V3 Z; y/ R$ v" }
queryEnvelope: 查询红包信息$ f1 l& A# M% b
claimEnvelope: 抢红包% D) S. A. v3 c ~4 F7 d
#include8 o" { y3 k& ~8 B
using namespace ontio;" W, z" a* F1 a* K% a$ z4 S
class redEnvelope: public contract{1 u0 w+ ^) `' Z" A. M0 A
}
ONTIO_DISPATCH(redEnvelope, (createRedEnvelope)(queryEnvelope)(claimEnvelope));
我们需要在存储中保存一些关键的数据。在智能合约中, 数据以 KV 的形式保存在该合约的上下文空间中,这些数据的 KEY 需要设置前缀以便于后面的查询。下面定义了三个不同的前缀供使用:
std::string rePrefix = "RE_PREFIX_";
std::string sentPrefix = "SENT_COUNT_";2 c D$ q5 t2 t% R/ d$ c, M
std::string claimPrefix = "CLAIM_PREFIX_"8 k6 ~# T; V F# f; ~* J$ G7 f. v
因为我们的合约支持 ONT 和 ONG 这两种 Ontology 的原生资产, 我们可以预先定义好这两种资产的合约地址。不同于标准的智能合约, Ontology 原生合约(native contract)的合约地址是固定的,而不是根据合约代码的 hash 计算而来的。1 l1 ]! | c$ v% Z* f7 U* F3 f
address ONTAddress = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
address ONGAddress = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2};
我们需要在合约中保存红包的信息, 如红包的资产信息(token 的合约地址, 红包的总金额, 红包的个数等等)& `- p! ~% |0 o8 b+ Q& e0 I) q( n
struct receiveRecord{
address account; //用户地址
asset amount; //抢到的金额
ONTLIB_SERIALIZE(receiveRecord,(account)(amount))
};
struct EnvelopeStruct{
address tokenAddress; //资产token的地址; e' W. f" {, b6 U: G% ] n
asset totalAmount; //红包总金额
asset totalPackageCount; //红包总数' p* [$ h$ Q" E7 F @
asset remainAmount; //当前剩余的金额7 W% x U7 x0 M
asset remainPackageCount; //当前剩余的红包数3 _, t; P. R/ |. q/ ^
std::vector records; //已经抢完的记录
ONTLIB_SERIALIZE( EnvelopeStruct, (tokenAddress)(totalAmount)(totalPackageCount)(remainAmount)(remainPackageCount)(records) )0 o1 w3 S# d: K: n2 M
};8 h1 F* k; U, J: M- T( w
其中,
ONTLIB_SERIALIZE(receiveRecord,(account)(amount)) K" W, _3 A, [9 P N; c0 `
是由 Ontology Wasm CDT 定义的宏操作,用于在将 struct 存储前进行序列化的操作。1 G" T e1 O7 u! K& V
2.2 创建红包
准备工作差不多了,下面我们开始开发具体的接口逻辑。
创建红包需要指定创建者地址, 红包数量, 红包金额和资产的合约地址:9 r& s- u, @: v& E' D. Y% H. D
4 _* K8 Y1 |. V. f2 D, E7 a) q8 U; \3 G
bool createRedEnvelope(address owner,asset packcount, asset amount,address tokenAddr ){2 L( M9 k0 K' G7 t, X f, e
return true;# o" Y1 U/ \, p* d0 m" G
}5 J0 K2 @ Z6 `4 r5 I2 X& k
检查是否有创建者的签名, 否则交易回滚退出:
ontio_assert(check_witness(owner),"checkwitness failed");$ _5 L& D$ y3 M* H- m# n( A7 C
NOTE: ontio_assert(expr, errormsg):当 expr 为 false 时, 抛出异常并退出。! x+ B' c) M8 q& m
如果红包资产是 ONT,由于 ONT 的不可分割性(最小为1个 ONT), 红包的金额要大于或等于红包的数量,保证每个红包最少有1个 ONT:
if (isONTToken(tokenAddr)){0 h( K, K. x; R# `# q' Z$ { d
ontio_assert(amount >= packcount,"ont amount should greater than packcount");7 I6 }: T9 D7 E+ f5 B9 c V
}
对于每个红包的创建者,我们需要记录一下他发送红包的总数量:
! F$ w' Z+ i- C# ?: _2 Z& G
key sentkey = make_key(sentPrefix,owner.tohexstring());
asset sentcount = 0;& }1 j! i/ h; I3 F* B! I
storage_get(sentkey,sentcount);8 ]0 {( K9 i' Q2 F8 C. Y# {
sentcount += 1;
storage_put(sentkey,sentcount);
生成红包 hash, 这个 hash 就是之后标识这个红包的唯一 ID:" L+ g. E% R* t
H256 hash ;
hash256(make_key(owner,sentcount),hash) ;
key rekey = make_key(rePrefix,hash256ToHexstring(hash));
根据 token 资产的类型,将资产转入合约中,self_address()可以取得当前执行的合约地址, 我们根据用户输入的 token 类型,将指定数量的 token 转入合约:; a/ h! u0 d: k' }8 J- a$ n
, O: T( M; W, j! g! Z
address selfaddr = self_address();
if (isONTToken(tokenAddr)){
bool result = ont::transfer(owner,selfaddr ,amount);
ontio_assert(result,"transfer native token failed!");! Q8 _1 @- z" M9 }& F( ?7 q
}else if (isONGToken(tokenAddr)){
bool result = ong::transfer(owner,selfaddr ,amount);, l- ], @, P. ]6 _; v; X. t) N P/ e" b
ontio_assert(result,"transfer native token failed!");& \6 B0 |; H2 |* S
}else{# K' n8 c, D9 l" r0 k/ E
std::vector params = pack(std::string("transfer"),owner,selfaddr,amount);
bool res;
call_contract(tokenAddr,params, res );
ontio_assert(res,"transfer oep4 token failed!");+ `8 Z* ~& h5 J. A; a5 x
}
NOTE 1:对于 ONT 和 ONG 这两种原生资产, Ontology Wasm CDT 提供了ont::transfer API 进行转账操作;而 OEP-4类的资产,需要按照普通的跨合约调用方法来转账。
NOTE 2:和普通的钱包地址一样, 合约地址也可以接受任意类型的资产。但是合约地址是由合约编译后的二进制代码 hash 产生的,所以没有对应的私钥,也就无法随意操作合约中的资产,如果你没有在合约中设置对资产的操作,就意味着你将无法控制这部分资产。0 h' h; O0 ]6 p% B
将合约的信息保存在存储中:
9 Z7 z$ N% V5 o
struct EnvelopeStruct es ;8 f o& j8 f3 y* x$ @3 }
es.tokenAddress = tokenAddr;5 @6 e' [: R' P- ?& d1 x
es.totalAmount = amount;0 E: X8 c6 h9 u/ v
es.totalPackageCount = packcount;5 J, o# b& v8 S# j
es.remainAmount = amount;+ d4 b; j( ]4 n/ B7 Z0 w, Z1 H) H
es.remainPackageCount = packcount;
es.records = {};" G) z9 ?, V1 P
storage_put(rekey, es);# n$ `8 f1 ~1 B* x
发送创建红包的事件。对于智能合约的调用是一个异步的过程,合约会在执行成功后发送一个事件来通知客户端执行结果,这个事件的格式可以由合约的编写者来指定。- r: ~* A& R$ |/ c
5 B) v+ l1 @1 F9 I) h
char buffer [100];
sprintf(buffer, "{\"states\":[\"%s\", \"%s\", \"%s\"]}","createEnvelope",owner.tohexstring().c_str(),hash256ToHexstring(hash).c_str());& F- w/ ?. b4 h6 R, l$ a
notify(buffer);) g$ W" o x( C' E+ _$ n. i
return true;" a6 j+ l" ~/ Z8 _
一个简单的红包就创建完成了, 下一步我们需要实现如何查询这个红包的信息.
2.3 查询红包6 i' _* C* R) h& l* t
查询红包的逻辑非常简单, 只需要将存储中的红包信息取出并格式化返回即可:* q0 R+ Y- j0 ~ ?% l
std::string queryEnvelope(std::string hash){
key rekey = make_key(rePrefix, hash);
struct EnvelopeStruct es;
storage_get(rekey, es);
return formatEnvelope(es);
}
NOTE:对于智能合约的只读操作(例如查询), 可以通过预执行(pre-exec)来读取结果。不同于普通的合约调用,预执行不需要钱包的签名,同时也就无需花费 ONG。最后,其他用户可以根据 hash(红包的 ID)来领取(抢)这个红包了。
2.4 领取红包; ]1 L3 }, I, F3 | j
我们已经把资产成功地转入到智能合约中了, 接下来就可以把这个红包的 ID 发送给你的朋友们让他们去抢红包了。
领取红包需要输入领取人的账户和红包的hash:* c: H5 q0 d% o$ L0 X
bool claimEnvelope(address account, std::string hash){ b* c5 ? K) l6 p+ a3 r( q' |
return true;# d) M0 e* t9 t
}
同样, 我们需要验证领取账户的签名, 不允许替其他人抢红包, 而且每个账户每个红包只能抢一次:$ I0 e5 g5 x1 I3 ^- B
ontio_assert(check_witness(account),"checkwitness failed");0 _2 `( O4 _1 f7 |9 K, {
key claimkey = make_key(claimPrefix,hash,account);
asset claimed = 0 ;
storage_get(claimkey,claimed);( G/ n) Q2 T& r
ontio_assert(claimed == 0,"you have claimed this Envelope!");
按照 hash 从存储中取出红包的信息, 判断这个红包是否没有被抢完:4 a4 m5 v$ }: _0 T+ W/ L% B
key rekey = make_key(rePrefix,hash);; q' N* d5 j$ Q1 _1 j6 G+ G
struct EnvelopeStruct es;
storage_get(rekey,es);4 Y! \. r; g8 ^) d- z
ontio_assert(es.remainAmount > 0, "the Envelope has been claimed over!");& w& S2 s! K% V& w5 G6 n
ontio_assert(es.remainPackageCount > 0, "the Envelope has been claimed over!");
新建一条领取的记录:
H1 ~) m2 e8 J9 f/ j
struct receiveRecord record ;( F/ |# C5 ?1 r" D1 y( }
record.account = account;
asset claimAmount = 0;
计算本次领取红包的资产数量。如果是最后一个红包, 数量为剩余的金额, 否则根据当前区块 hash 计算随机数,确定本次领取的数量, 并更新红包信息:
if (es.remainPackageCount == 1){
claimAmount = es.remainAmount;* Y2 U; R& A1 ], R$ ^( B
record.amount = claimAmount;
}else{
H256 random = current_blockhash() ;7 g! a3 x9 K2 W' h/ l' O3 v
char part[8];
memcpy(part,&random,8);0 `8 a' i' N8 @3 f
uint64_t random_num = *(uint64_t*)part;
uint32_t percent = random_num % 100 + 1;, a/ q; v, I9 B% T, T2 i
claimAmount = es.remainAmount * percent / 100;! ]; R' U7 @6 z
//ont case8 z. P. t$ J2 U; Q+ f, n" n
if (claimAmount == 0){
claimAmount = 1;
}else if(isONTToken(es.tokenAddress)){ i7 r2 u4 C0 P
if ( (es.remainAmount - claimAmount) 根据计算结果, 将对应资产从合约中转到领取的账户:
, b: h7 C( Z. v+ Q4 X% F
address selfaddr = self_address();" M6 f8 o$ j; c' A
if (isONTToken(es.tokenAddress)){) D$ q* F, r, r8 U% K( j4 |; w
bool result = ont::transfer(selfaddr,account ,claimAmount);" m- c+ y: u! s) y+ E( e
ontio_assert(result,"transfer ont token failed!");$ p& ]1 N) |8 k# u# ]. t
} else if (isONGToken(es.tokenAddress)){. _) d2 |2 e" A; F
bool result = ong::transfer(selfaddr,account ,claimAmount);# L( H& x: s' @9 ]7 T0 X, u
ontio_assert(result,"transfer ong token failed!");0 k( O8 `: Y, N- e0 q' ~
} else{$ f- w( C. W! i8 U' x, r; f4 \8 I
std::vector params = pack(std::string("transfer"),selfaddr,account,claimAmount);
bool res = false;
call_contract(es.tokenAddress,params, res );" g$ i/ d/ z8 h- P+ p& [
ontio_assert(res,"transfer oep4 token failed!");5 U9 w2 ~( ^/ P* ]9 T1 a& u" B
}
记录领取的信息, 将更新后的红包信息写回存储并发送通知事件:8 t7 V$ p, ~- V+ N9 `
storage_put(claimkey,claimAmount);/ a9 J! ~+ f4 h2 O
storage_put(rekey,es);
char buffer [100];
std::sprintf(buffer, "{\"states\":[\"%s\",\"%s\",\"%s\",\"%lld\"]}","claimEnvelope",hash.c_str(),account.tohexstring().c_str(),claimAmount);. G. u6 B' T2 D8 N) s
notify(buffer);% v, A$ d5 o7 a
return true;
如前面所说,这个合约只能通过 claimEnvelope 这个接口将资产转出合约。所以,合约中的资产是安全的,任何人都无法随意的取走里面的资产。
至此, 一个简单的红包合约逻辑完成, 完整的合约代码如下:https://github.com/JasonZhouPW/pubdocs/blob/master/redEnvelope.cpp
2.5 合约测试
合约测试可以有两种方法:6 N& g1 K C) N: X+ i2 m
使用 CLI) s8 I; U* A. y; l
请参考:https://github.com/ontio/ontology-wasm-cdt-cpp/blob/master/How_To_Run_ontologywasm_node.md! S/ h0 {. S! z" n, T
使用 Golang SDK7 T2 z0 d2 p5 C6 Z7 b% p
请参考:https://github.com/ontio/ontology-wasm-cdt-cpp/blob/master/example/other/main.go% P0 _4 L4 C- V% v7 w# E' o& I
三、总结0 H' s" h& |7 t
本示例只是为了展示如何编写一个完整的 Wasm 智能合约, 如何通过调用 API 和底层的区块链进行交互。如果要作为正式的产品, 还需要解决红包的隐私问题: 所有人都可以通过监控合约的事件来取得红包的 hash, 意味着每个人都可以抢这个红包。一种比较简单的解决方法,就是在创建红包时指定哪些账户能够领取。如果有兴趣, 您也可以尝试修改测试一下。
我们欢迎更多的 Wasm 技术爱好者加入本体开发社区,共同打造技术生态。
成为第一个吐槽的人