手把手教你Wasm合约开发(C++篇)
放弃六月们
发表于 2023-1-9 00:14:24
107
0
0
一、Hello World+ P9 D4 R" P; Q: M
按照惯例,我们还是从一个 Hello world 开始 M, k' q6 q2 k: b* j! f
#include#include
using namespace ontio;class hello:public contract {: p9 b/ x7 Q( w1 `( s, ~
public:, _4 H) R, d3 A4 u) t) n
using contract::contract:
void sayHello(){' ]% F9 ]; w( ~' U, H
printf("hello world!");
}& |6 o# ?) w/ Y3 [( r2 X F$ ]
};6 X' q3 o! s" t- D2 H& D
ONTIO_DISPATCH(hello, (sayHello));
1.1 合约入口: F5 B9 W; h5 \9 Z
Ontology Wasm CDT 编译器已经对入口和参数解析进行了封装,所以开发者不需要重新定义入口方法。接下来是定义合约的对外接口,这是智能合约对外提供服务的方法。% l) F+ Z7 j$ L2 S
ONTIO_DISPATCH(hello, (sayHello));' _* m7 U2 y. E+ X1 \5 I
在上面的例子中, 我们暂时只支持 sayHello 这个方法:. h& l0 f. c+ G2 ?
printf("hello world!");
这个“Hello world!”会在节点的日志中以调试信息打印出来。在实际的应用中, printf 只能用作调试的目的, 一个实际的智能合约,需要实现更多更复杂的功能。
1.2 智能合约 API1 M' `/ H4 \' ]% N% P6 `9 y
Ontology Wasm 提供如下 API 与区块链的底层进行交互:1 K4 [3 j+ A! A! i- O. Y
二、红包合约
下面我们通过一个更加复杂的例子来演示如何通过这些 API 来开发一个完整的 Wasm 智能合约。
很多情况下我们都会通过各种 App,如微信等聊天工具发红包。我们可以给朋友发送红包,也可以抢其他人发送的红包,收到的钱会记入到个人微信账户中。
类似于微信的流程,我们将尝试创建一个智能合约。用户使用该合约,可以发送 ONT,ONG 或者是标准的 OEP-4的 Token 资产红包给他的朋友们,而朋友们抢到的红包可以直接转入到他们的钱包账户中。& ], ` q2 d5 ~: A
2.1 创建合约' H' Q- d; N J" _( v9 v
首先,我们需要新建合约的源文件,暂且命名为 redEnvelope.cpp。这个合约我们需要三个接口:
createRedEnvelope: 创建红包
queryEnvelope: 查询红包信息
claimEnvelope: 抢红包
#include
using namespace ontio;+ {6 ^/ ]8 d8 {, [3 z8 |. W% M& e7 {( S
class redEnvelope: public contract{2 H! P Y- U( v% c7 ^9 G# {, L
}
ONTIO_DISPATCH(redEnvelope, (createRedEnvelope)(queryEnvelope)(claimEnvelope));+ d* A7 @ T5 x; Q q
我们需要在存储中保存一些关键的数据。在智能合约中, 数据以 KV 的形式保存在该合约的上下文空间中,这些数据的 KEY 需要设置前缀以便于后面的查询。下面定义了三个不同的前缀供使用:
std::string rePrefix = "RE_PREFIX_";
std::string sentPrefix = "SENT_COUNT_"; J/ m% _- t# d' M
std::string claimPrefix = "CLAIM_PREFIX_"
因为我们的合约支持 ONT 和 ONG 这两种 Ontology 的原生资产, 我们可以预先定义好这两种资产的合约地址。不同于标准的智能合约, Ontology 原生合约(native contract)的合约地址是固定的,而不是根据合约代码的 hash 计算而来的。7 X+ ~2 U8 b: o5 j9 R' g' {7 E3 f" E
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};7 @" Y- F5 r% ^0 t$ V$ i A5 ]
我们需要在合约中保存红包的信息, 如红包的资产信息(token 的合约地址, 红包的总金额, 红包的个数等等)% M, R) Z- P. V* }
struct receiveRecord{/ ?9 k" S8 e1 ?) C) r
address account; //用户地址
asset amount; //抢到的金额" M0 `8 l( |" h1 S
ONTLIB_SERIALIZE(receiveRecord,(account)(amount))
};
struct EnvelopeStruct{. J, |9 Y0 Z3 \5 z
address tokenAddress; //资产token的地址/ r& m3 d) m; R2 e5 D+ u: N
asset totalAmount; //红包总金额. E8 B+ |' h$ J3 o @* E
asset totalPackageCount; //红包总数
asset remainAmount; //当前剩余的金额# K: x1 A) ]1 c9 C' e
asset remainPackageCount; //当前剩余的红包数
std::vector records; //已经抢完的记录! z* A7 ]" W/ M6 g/ f$ E
ONTLIB_SERIALIZE( EnvelopeStruct, (tokenAddress)(totalAmount)(totalPackageCount)(remainAmount)(remainPackageCount)(records) )3 ^8 x, J9 a& t! V* \ Z4 R4 m( z
};
其中,
ONTLIB_SERIALIZE(receiveRecord,(account)(amount))
是由 Ontology Wasm CDT 定义的宏操作,用于在将 struct 存储前进行序列化的操作。/ l' `4 n" g4 j% d8 Z: y, G' v* ?* ~
2.2 创建红包
准备工作差不多了,下面我们开始开发具体的接口逻辑。
创建红包需要指定创建者地址, 红包数量, 红包金额和资产的合约地址:8 G* _, G/ ]: e# V3 j; H/ X
bool createRedEnvelope(address owner,asset packcount, asset amount,address tokenAddr ){
return true;9 J2 l: R0 p* g9 c
}
检查是否有创建者的签名, 否则交易回滚退出:# A, s1 m+ C) P+ v" [1 q
4 f! @, q' Y/ {* L$ K( r& K( L1 X
ontio_assert(check_witness(owner),"checkwitness failed");
NOTE: ontio_assert(expr, errormsg):当 expr 为 false 时, 抛出异常并退出。
如果红包资产是 ONT,由于 ONT 的不可分割性(最小为1个 ONT), 红包的金额要大于或等于红包的数量,保证每个红包最少有1个 ONT:
$ J8 B2 g- y+ l% D( J) F
if (isONTToken(tokenAddr)){
ontio_assert(amount >= packcount,"ont amount should greater than packcount");3 g0 B4 k2 ^0 n9 _4 U* H, ?" y
}* b( M3 ~- V9 l2 e, M) N
对于每个红包的创建者,我们需要记录一下他发送红包的总数量:* A3 b. [9 ^; v7 a+ b
key sentkey = make_key(sentPrefix,owner.tohexstring());" H9 Q$ c3 Z0 D( Q
asset sentcount = 0;3 a1 z/ Y% I$ e3 J/ I4 a K& k
storage_get(sentkey,sentcount);
sentcount += 1;* [/ A$ Q$ y# f/ _ s0 C
storage_put(sentkey,sentcount);1 }, ~- d! F5 S7 u- i/ T
生成红包 hash, 这个 hash 就是之后标识这个红包的唯一 ID:- D& j* S% M; {
" l4 m, d, W' v) J9 j. \) ?+ M
H256 hash ;) F! e6 X8 h3 U$ O; ?/ ?" B
hash256(make_key(owner,sentcount),hash) ;
key rekey = make_key(rePrefix,hash256ToHexstring(hash));
根据 token 资产的类型,将资产转入合约中,self_address()可以取得当前执行的合约地址, 我们根据用户输入的 token 类型,将指定数量的 token 转入合约:1 V/ R6 G3 z4 e4 Z4 `# J
address selfaddr = self_address();
if (isONTToken(tokenAddr)){9 h. j; ~7 a: @- O! K D7 K
bool result = ont::transfer(owner,selfaddr ,amount);
ontio_assert(result,"transfer native token failed!");
}else if (isONGToken(tokenAddr)){3 _, L- r, c- c: h8 Q
bool result = ong::transfer(owner,selfaddr ,amount);; I/ _0 f5 Z+ \+ D1 e; f
ontio_assert(result,"transfer native token failed!");
}else{+ T/ T7 q( n9 H& i" d u
std::vector params = pack(std::string("transfer"),owner,selfaddr,amount);
bool res;
call_contract(tokenAddr,params, res );! ~; x( j/ ^ c! M
ontio_assert(res,"transfer oep4 token failed!");' p: e7 V7 r+ {" y
}
NOTE 1:对于 ONT 和 ONG 这两种原生资产, Ontology Wasm CDT 提供了ont::transfer API 进行转账操作;而 OEP-4类的资产,需要按照普通的跨合约调用方法来转账。
NOTE 2:和普通的钱包地址一样, 合约地址也可以接受任意类型的资产。但是合约地址是由合约编译后的二进制代码 hash 产生的,所以没有对应的私钥,也就无法随意操作合约中的资产,如果你没有在合约中设置对资产的操作,就意味着你将无法控制这部分资产。1 M" _$ D4 P, \6 O
将合约的信息保存在存储中:
7 w) K R) u8 T3 a- Q* W" a$ ]
struct EnvelopeStruct es ;/ b7 Y* d2 V* {
es.tokenAddress = tokenAddr;
es.totalAmount = amount;2 c) M5 k% C3 f$ q" a
es.totalPackageCount = packcount;/ S: ~7 k' @* Z, d% E
es.remainAmount = amount;, }0 f/ Z6 C/ n4 |9 H
es.remainPackageCount = packcount;
es.records = {};
storage_put(rekey, es);
发送创建红包的事件。对于智能合约的调用是一个异步的过程,合约会在执行成功后发送一个事件来通知客户端执行结果,这个事件的格式可以由合约的编写者来指定。
char buffer [100];" P, c" C5 j& Y1 k+ t5 p
sprintf(buffer, "{\"states\":[\"%s\", \"%s\", \"%s\"]}","createEnvelope",owner.tohexstring().c_str(),hash256ToHexstring(hash).c_str());0 h/ q5 U3 [+ _( H( o0 B
notify(buffer);
return true;* J, t% C+ v" T( e
一个简单的红包就创建完成了, 下一步我们需要实现如何查询这个红包的信息.
2.3 查询红包4 _! _- v2 o; g8 w
查询红包的逻辑非常简单, 只需要将存储中的红包信息取出并格式化返回即可:
std::string queryEnvelope(std::string hash){
key rekey = make_key(rePrefix, hash);- Q* X6 q5 _; ` p8 T3 I
struct EnvelopeStruct es;5 W- [' s7 \% m" c! ^1 N
storage_get(rekey, es);
return formatEnvelope(es);
}
NOTE:对于智能合约的只读操作(例如查询), 可以通过预执行(pre-exec)来读取结果。不同于普通的合约调用,预执行不需要钱包的签名,同时也就无需花费 ONG。最后,其他用户可以根据 hash(红包的 ID)来领取(抢)这个红包了。
2.4 领取红包
我们已经把资产成功地转入到智能合约中了, 接下来就可以把这个红包的 ID 发送给你的朋友们让他们去抢红包了。
领取红包需要输入领取人的账户和红包的hash:
bool claimEnvelope(address account, std::string hash){& @$ u$ r- q) A- o5 ?4 ~
return true;
}* V& o/ W0 k" f& G& F
同样, 我们需要验证领取账户的签名, 不允许替其他人抢红包, 而且每个账户每个红包只能抢一次:8 B9 f/ c# q2 A- \# [8 a
k1 W/ \( I7 i& @6 Q
ontio_assert(check_witness(account),"checkwitness failed");
key claimkey = make_key(claimPrefix,hash,account);
asset claimed = 0 ;3 {$ o, p: U8 o
storage_get(claimkey,claimed);1 u3 J' t) H3 g7 a' V/ X
ontio_assert(claimed == 0,"you have claimed this Envelope!");. @5 L! o1 B- t* j* V1 w4 h
按照 hash 从存储中取出红包的信息, 判断这个红包是否没有被抢完:- R6 G4 W6 [* c
key rekey = make_key(rePrefix,hash);. t; D# |9 l. t
struct EnvelopeStruct es;8 D+ p5 E$ p8 h3 v
storage_get(rekey,es);
ontio_assert(es.remainAmount > 0, "the Envelope has been claimed over!");
ontio_assert(es.remainPackageCount > 0, "the Envelope has been claimed over!");0 n- V. G9 K) Q1 x
新建一条领取的记录:- s% ^4 Y U6 U3 i0 P+ t/ C/ Z! N5 l
struct receiveRecord record ;
record.account = account;4 @8 G( p6 P" ?& ?
asset claimAmount = 0; W, F* f" \) B, ^: ^
计算本次领取红包的资产数量。如果是最后一个红包, 数量为剩余的金额, 否则根据当前区块 hash 计算随机数,确定本次领取的数量, 并更新红包信息:
" m/ h" k. X X& C% P8 z$ d
if (es.remainPackageCount == 1){
claimAmount = es.remainAmount;5 N6 n) l/ H* [- o+ k
record.amount = claimAmount;, o, `/ g* I; l5 E' v
}else{
H256 random = current_blockhash() ;# M- n7 i% i; y' W
char part[8];1 z- ^- L" J: e* ?1 B
memcpy(part,&random,8);- B5 i: ]0 W( R5 E3 D: L
uint64_t random_num = *(uint64_t*)part;% W' h5 ^9 L" K U* x
uint32_t percent = random_num % 100 + 1;
claimAmount = es.remainAmount * percent / 100;/ g0 y" s6 i6 Y8 |( ?
//ont case; i0 S( a; P) y- b1 h% c
if (claimAmount == 0){
claimAmount = 1;
}else if(isONTToken(es.tokenAddress)){
if ( (es.remainAmount - claimAmount) 根据计算结果, 将对应资产从合约中转到领取的账户: x6 t2 q/ n: f3 q
/ G) k4 g& M8 u. r( D+ \
address selfaddr = self_address();
if (isONTToken(es.tokenAddress)){
bool result = ont::transfer(selfaddr,account ,claimAmount);
ontio_assert(result,"transfer ont token failed!");' c+ U ^/ P2 |3 e# {7 J- O; D& U
} else if (isONGToken(es.tokenAddress)){7 e( [4 s0 L( n5 g
bool result = ong::transfer(selfaddr,account ,claimAmount);
ontio_assert(result,"transfer ong token failed!");
} else{
std::vector params = pack(std::string("transfer"),selfaddr,account,claimAmount);
bool res = false;
call_contract(es.tokenAddress,params, res );
ontio_assert(res,"transfer oep4 token failed!");
}
记录领取的信息, 将更新后的红包信息写回存储并发送通知事件:: R6 A) X2 J4 x
storage_put(claimkey,claimAmount);) h9 ~3 p R1 u, U- |
storage_put(rekey,es);, m5 @9 i7 Y* U# C- X) a. [
char buffer [100];$ J9 M' a* |6 @
std::sprintf(buffer, "{\"states\":[\"%s\",\"%s\",\"%s\",\"%lld\"]}","claimEnvelope",hash.c_str(),account.tohexstring().c_str(),claimAmount);/ V* ?% ^& w% S, F
notify(buffer);+ ^+ o" q. |( ]' D
return true;! K- w) L# @! k( P' d* b! T ]# t% _
如前面所说,这个合约只能通过 claimEnvelope 这个接口将资产转出合约。所以,合约中的资产是安全的,任何人都无法随意的取走里面的资产。
至此, 一个简单的红包合约逻辑完成, 完整的合约代码如下:https://github.com/JasonZhouPW/pubdocs/blob/master/redEnvelope.cpp
2.5 合约测试
合约测试可以有两种方法:
使用 CLI6 x* `$ c' z1 e& c6 p, X3 i, D
请参考:https://github.com/ontio/ontology-wasm-cdt-cpp/blob/master/How_To_Run_ontologywasm_node.md
使用 Golang SDK1 E* \4 F5 H( y. Z9 _
请参考:https://github.com/ontio/ontology-wasm-cdt-cpp/blob/master/example/other/main.go5 O" c# c4 C6 V1 S0 K, l
三、总结
本示例只是为了展示如何编写一个完整的 Wasm 智能合约, 如何通过调用 API 和底层的区块链进行交互。如果要作为正式的产品, 还需要解决红包的隐私问题: 所有人都可以通过监控合约的事件来取得红包的 hash, 意味着每个人都可以抢这个红包。一种比较简单的解决方法,就是在创建红包时指定哪些账户能够领取。如果有兴趣, 您也可以尝试修改测试一下。' D' B0 q1 q5 j, b2 ?& v2 j7 ~
我们欢迎更多的 Wasm 技术爱好者加入本体开发社区,共同打造技术生态。
成为第一个吐槽的人