Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

以太坊开发演练从智能合约开始

人民干脆面
98 0 0
智能合约,众筹,Mist,Metamask,Remix,geth,web3……如果你花过一点时间尝试了解以太坊的开发,你大概对这些并不陌生。
" b" ?+ L. R6 N! n/ l: f0 k: d/ F
    一些人在测试网络中部署智能合约,另一些人告诉你要读黄皮书,而另一些人则建议你使用truffle套件,因为它很有帮助。但其实你并不知道该做什么,也不知道这些东西放在一起是怎么用的。
( M" p  _9 O5 c+ |- F- ]0 ^& t. t& H# z/ B8 v
    如果这是你读到的第一篇关于以太坊或区块链生态系统的文章,你会爱上以太坊的!虽然“专家们”在twitter上互掐,有很多不安全的标准和协议,未经测试有bug的开发工具……并不是所有的问题都已经解决,但每个人都在朝着不同的方向前进探索,任重而道远。机构、银行和政府的未来将由这些疯狂的开发者决定!这真是太棒了。
& g4 q% [+ x! R9 L& v/ b, e  L8 ~  o1 n3 ^% O+ \0 ^; k
    不管怎样,别担心,我会努力把本系列教程中所有的信息点串连起来,带你走进智能合约和dapps的开发世界,向你展示各部分是如何配合工作的。
# }  [" a2 ]3 a/ b
- K, e! y8 g6 D; F( w    虽然我不会对每一个细节进行阐释,但我会给你一些阅读材料的链接,这些材料能帮助你更好地理解某些概念,这要靠你自己研究并了解所有的细节。这个系列的目的就是以最简单的方式,帮助你更好地理解各部分是如何协同工作的,就像一个朋友向你解释说明那样。
1 F  O& y5 p; G! F  v; u6 W! K  E1 z: }9 r4 |$ ]1 p" A
    我甚至不知道以太坊是什么2 P+ N/ V' B: v& A- d6 m
: ]/ y# h! W& L0 ]
    以太坊的官方网站告诉我们:
& Z- Q* I* B4 j) ~. h! e3 R% L9 @3 f3 p: `6 Z" \
    以太坊是一个运行着智能合约的分布式平台:应用程序完全按照程序运行,不存在故障、审查、欺诈或第三方干预的可能性。
2 h! u( s5 j& ~5 K' I- c4 S1 T
; J% }& ]: r4 E" ]    换句话说,以太坊给予了我们使用区块链技术来验证我们运行的代码的执行情况的能力。+ `% E6 i( B/ u" M, Q& b( |( e
8 D. n- ?1 P! ]- s
    如果你不知道区块链、以太坊、比特币、加密货币这些词的含义,我建议你听听TimFerriss采访NickSzabo和NavalRavikant的精彩播客:沉默的加密货币大师——NickSzabo。
8 c4 T. X. W5 @3 M! k8 a. A2 m2 Q: T/ H6 r4 E. ?/ |( ^1 r, i, f
    智能合约是什么?) T- d+ w5 e. s8 v5 W, U

, O2 c& D4 J  n0 s    在以太坊,智能合约是可以处理资金的脚本。就是这么简单。' O" e7 m2 J! E9 d; n
% h. H$ c9 }7 ]7 p# S  ?# J! [
    这些合约由我们称为“矿工”的参与方强制执行和证明。矿工其实是多台电脑,它们把一项交易(执行智能合约,支付加密货币等)添加到一个公开分类账上,我们称之为区块。多个区块构成一个区块链。! `4 U9 N) b3 s/ o1 c- t! h1 P
- M1 |$ _* \1 w  b2 f
    我们给这些矿工支付一种叫作“Gas”的东西,它是运行一份合约的成本。当你发布一份智能合约,或者执行一份智能合约,或者把钱转到另一个账户,你就要支付一些被转换成Gas的以太币。8 p  l$ V. u0 ]: w8 a$ v! r/ g0 Q. j! J

* O- k; S* W% N6 N    在深入智能合约的开发之前$ r7 p7 ~1 W% r: o' A( W
1 T. N6 F6 D# {, b! }# ?8 Q
    在本教程中,我会假设你已经在软件开发方面有了一定的基础,并且具备了Javascript和Node.JS的基本知识。否则,你很快会看不懂。Solidity是我们用来开发的编程语言,它与Javascript的语法非常接近,而且由于以太坊周围很多的开发工具都是基于Javascrip和Node.JS.的,所以如果你对两者都已经很熟悉的话,那你就更容易理解。这不是针对初学者的教程,如果你不理解一些概念,我会为给你一些替代教程的链接,剩下的部分靠你自己研究吃透。
9 F1 [1 w* A, A7 f. u9 [. W: h1 A
- P* F( C. @6 J7 H; ^    智能合约开发
2 X# k5 w7 q  ]* M+ u6 ?& u! V) z7 I; w6 C: z( D
    现在,我们开始有趣的部分,正如我所说的,Solidity与Javascript很接近,但它们并不相同。关于Solidity,我很遗憾地告诉你,作为前端开发人员,你不能在一段代码上强加JQuery并希望它能起作用,你不能忽略安全性,不能“另辟蹊径”。我们会在讨论安全性、开发模式和防止代码故障的时候知晓原因。; m) @/ E; Z. F+ h& F, v6 j
+ I) v# M  A  E8 S3 V/ H/ g! V
    现在,关于我们的第一个例子,我正在考虑一个由电影《时间规划局》启发的脚本。电影中,人们生活在一个反乌托邦式的未来,改用时间作为货币流通。他们可以通过掰手腕的方式赢取对手的时间(他们的“手臂”上存储着时间,输方的时间将会传送给赢家),我们也可以这么做!用智能合约以角力(Wrestling)的方式赚钱。
5 m8 t" {8 Q4 |' H6 z( i. K
6 J! {4 n' a- q8 A    别担心,我会在Github上为你提供接下来我们会看到的所有脚本。
; I# K. v5 B* S3 B/ x2 T$ l/ m0 J  u7 s1 `% }1 w" D. r
    另外,如果这是你第一次处理智能合约,如果你现在不了解所有的事情那也没关系,你需要练习、阅读文档和做一些研究来熟悉Solidity。
5 N( B% g! U% ~$ a+ ^. R) y5 x4 d5 I# N8 s
    代码9 t; V% u. X+ d. M
( x' S" }+ y  S4 G1 n
    现在话题转到写代码上,首先,solidity脚本的基础是下面这段代码,pragma指令会告诉编译器我们正在使用的Solidity版本,以及我们的合约名称,是一种与Javascrip上的类(class)相似的结构。这就是“Wrestling(角力)”。
2 d% i" r3 z- p& b2 z/ G
4 e) P  R' }, ?3 ~8 L    pragmasolidity^0.4.18;
# E- R9 Z) j4 ^& E. e. T! e( }$ C' V0 G& q" E* X" Q4 Z
    contractWrestling{
, a" J" ~+ J' ?  B. F9 e: ?' ]# z" c1 o4 w7 b4 O! p& M
    //ourcodewillgohere0 o' U$ Y1 o3 x! q3 S; r
4 Z" F" t; Z' ]
    }$ h' l/ }# J& V: D) F+ J# I$ f5 H
. u" u# r( }5 \. ^* r, X) i; y
    我们需要两个参与者,所以我们要添加两个保存他们账户地址的变量(他们钱包的公钥)。7 z$ \$ {' M1 b" B, z) ^( m

5 |4 h- q" y2 `7 D    addresspublicwrestler1;6 S. F3 c' K2 B$ o/ ?, M
# F  n( r9 U# P) e
    addresspublicwrestler2;
2 Q3 c3 P. D3 b0 `- l# X9 Z/ D4 j! r
    在我们的小游戏中,每一轮的比赛,参与者都可以投入一笔钱,如果一个人投入的钱是另一个人的两倍(总计),那他就赢了。
0 ^$ r3 _! N! x5 u9 m3 ^  T* W6 o- b3 [, q0 U) g: t* I6 [2 ~1 ^0 V
    boolpublicwrestler1Played;' F+ r  s" y; f5 N4 _! [9 A
5 Y" F% u: I# a# n- r3 D3 `9 P
    boolpublicwrestler2Played;
. A) N0 o/ K+ j1 I
' i, t- j7 g& o+ D; {    uintprivatewrestler1Deposit;
$ l7 O. x' G) B! S1 b3 J9 g
% [4 s1 m; h4 A$ D+ y    uintprivatewrestler2Deposit;! e9 \( c7 f+ X# L( H. ?

- ^! k; x& K. x& L    boolpublicgameFinished;
( G7 o2 R% o, S- x, }' v  w  y. ^! I
    addresspublictheWinner;. h/ x4 {% Q" ~0 `  P% a
' j, U7 C$ Z  g- V2 q' K; {4 G8 f
    uintgains;
- r( E! Q+ G: _8 e- H
5 G: H# [1 N* q/ H* T% L    关于公钥/私钥的一件重要的事项是,即使一个变量是私有的,但并不意味着其他人不能读取它的内容,它只是意味着它只能在合约中被访问,但实际上,由于整个区块链存储在许多计算机上,所以存储在变量中的信息总是可以被其他人看到,这是你应该记住的第一个安全考虑。3 P; ?* a8 _; d9 G" i
+ V& J' B7 ]3 N' m1 i
    另一方面,编译器会自动为公共变量创建getter函数。为了使其他的合约和用户能够更改公共变量的值,你需要创建一个setter函数。, E: ?2 l2 W3 k8 e

1 b! G: D, v" e    现在我们将为游戏的每一步添加三个事件。开始,参与者注册;游戏期间,登记每一轮赛果;最后,其中一位参与者获胜。事件是简单的日志,可以在分布式应用程序(也称为dapps)的用户界面中调用JavaScript回调函数。在开发过程中,事件甚至可以用于调试的目的,因为它不同于JavaScript在Solidity上的console.log()函数。9 l) N9 W. F$ P0 K
1 s# P) \$ K% L+ z( u( @3 g
    eventWrestlingStartsEvent(addresswrestler1,addresswrestler2);+ L& d9 ~! l9 }

; D; U& w" d  f' h4 N    eventEndOfRoundEvent(uintwrestler1Deposit,uintwrestler2Deposit);% j: J+ |1 r: ~6 L$ X

  z! o( Y- R, v5 i9 v! n5 q    eventEndOfWrestlingEvent(addresswinner,uintgains);
0 r) ~- O  q. n; q) V
  y/ E9 @1 w0 y& b( w+ ^- X; Y' ?    现在我们将添加构造函数,在Solidity中,它与我们的合约具有相同的名称,并且在创建合约时只调用一次。
& Q8 h, ?7 D2 Z3 M6 n0 m# G
( X% x: [) P" S8 }7 B* N, o4 e    在这里,第一位参与者将是创造合约的人。“msg.sender”是调用该函数的人的地址。
* w& J3 b' V4 D% u3 ?7 k# Z
( X( K3 N8 b, K+ ?    functionWrestling()public{9 ^  V8 U- C0 [3 \

- u5 ^0 s2 z' ]) d3 e* z    wrestler1=msg.sender;
  o: B8 f3 {2 o/ K( d7 [; E% U8 v
: x+ Q. R$ g. l0 N% N8 b    }# B" A& Z# d5 H

' C' h$ H& ?1 h- O% {1 X3 k. {    接下来,我们让另一个参与者使用以下函数进行注册:
9 ~. A, c8 c. V  C0 L
) c/ e8 Z% i$ Z+ C    functionregisterAsAnOpponent()public{
4 y* Q3 O/ E. S8 [7 D
6 c9 i3 b! ^, P% A- c# Q+ ?    require(wrestler2==address(0));
6 l5 r( p2 C1 w$ `
! r" A9 z9 B8 Z( K" e    wrestler2=msg.sender;3 z5 I  l! x. j2 v1 T8 M# O

2 n# F5 h. I: {8 Y* }+ S    WrestlingStartsEvent(wrestler1,wrestler2);
; P9 f( [- g3 U  f6 Y; C5 s! v3 k( u& S* S. s' \
    }2 v! _% h- s; C  y0 C2 a5 O
' M/ j& [/ ]3 h5 Y
    require函数是Solidity中一个特殊的错误处理函数,如果条件不满足,它会回滚更改。在我们的示例中,如果变量参与者2等于0x0地址(地址等于0),我们可以继续;如果参与者2的地址与0x0地址不同,这就意味着某个玩家已经注册为对手,所以我们会拒绝新的注册。
- @! Y0 t4 {# h; L' c9 a3 A! L7 C  d( Z! Q: M' t7 C" y
    再次强调,“msg.sender”是调用该函数的帐户地址,并且当我们触发一个事件,就标志着角力的开始。
7 J0 h- \' a2 Q$ ?; g. B, i( ~/ V+ p; z# o+ c- c
    现在,每一个参与者都会调用一个函数,“wrestle()”,并投入资金。如果双方已经玩过这场游戏,我们就能知道其中一方是否获胜(我们的规则是其中一方投入的资金必须是另一方的双倍)。关键字“payable”意味着函数可以接收资金,如果它不是集合,函数则不会接受以太币。“msg.value”是发送到合约中的以太币的数量。
1 M9 q6 @, U+ X, ^/ J3 S. n$ a/ v
/ N9 M1 u7 _& ~( P    functionwrestle()publicpayable{
6 a& X. S6 B4 j) d- t
5 }. C' |' B+ d    require(!gameFinished&&(msg.sender==wrestler1||msg.sender==wrestler2));* C2 P- z7 A* m' S! T

* _" q% a7 J5 i7 }. M* p+ t  k; U. Z    if(msg.sender==wrestler1){- j8 T9 ^, o% _$ \# n. X& U* ]

' v& Z4 m4 u% m( R& f% w  i* u# x  \    require(wrestler1Played==false);
; w! X1 x2 c/ u5 l+ \0 e; H2 h, V: w
    wrestler1Played=true;3 B  M  p# S4 H* B

- E! t% D* y' d* a6 j/ _    wrestler1Deposit=wrestler1Deposit+msg.value;
. ~1 A$ ^2 Y7 c2 ~& S* v! H, {6 Q0 c- v8 E
    }else{
% b, I" w. y/ r, w& `7 I4 I4 S
1 S7 w* r1 Q6 q    require(wrestler2Played==false);
5 Z/ p8 e9 c% p& j. R" ]8 M  Q9 C" }0 u5 G
    wrestler2Played=true;4 i2 w3 s8 _0 h  g% Z

2 G1 o  |3 u' Q    wrestler2Deposit=wrestler2Deposit+msg.value;
; T; j! D* C* M, m1 h) q
& i/ c( }' y! e& N    }3 D: r: {2 g. j; S5 I7 S
  i/ T! }" b: J+ n/ @1 R+ C# m
    if(wrestler1Played&&wrestler2Played){& a  x; I3 ?2 Y# V
1 C, ^0 G/ W) s; J4 h& e' V
    if(wrestler1Deposit>=wrestler2Deposit*2){$ Z$ w! f1 l0 i* C0 ^! U. W3 r

. r( x+ t$ b: O9 J7 X, v    endOfGame(wrestler1);8 f6 {! S- X! O1 S4 s& a2 w  ?; m

0 t; L# ]0 {( y6 T    }elseif(wrestler2Deposit>=wrestler1Deposit*2){
7 [- p8 K1 o3 P$ w5 l- F8 P% U2 p1 ^( `9 u
    endOfGame(wrestler2);
0 A! K1 p" V( ?# C9 m! D/ k1 W' ]3 f" o/ X- Z9 r
    }else{: ~/ H) S* D9 Q6 _9 z: e0 k* ~

7 i6 I5 `0 h& L4 g( ]    endOfRound();
& T* w/ w9 g6 o0 Y4 w) e- M6 g3 z% F
    }
/ L8 V# q3 e' Q- q$ h1 o. C, Y; ^( U& j  k5 [& z* |
    }5 g& u' R+ s2 J1 g5 ~9 B) J
- M% I7 D5 `! E+ s8 k
    }
( u6 w. T( R" M- I( F% n2 b
7 w3 ?* W- ^8 u& p    然后,我们添加endOfGame()和endOfRound()函数。关键字“internal”与“private”是一样的,唯一的区别是internal函数可以由其他合约继承(因为Solidity与其他面向对象语言相似),而private函数不能继承。
5 V4 I! c$ \' Q' p% T7 n1 ^; ^+ X+ l: d  I1 [" C
    functionendOfRound()internal{
3 n8 U3 {2 {; D5 h' {# g: B9 _$ h8 G
    wrestler1Played=false;
7 _1 G  Q' Z$ B' \% `9 S& I) `' [' J" ?" i
    wrestler2Played=false;
  j% w2 \5 h' t. u4 W. M  Y  f
- m; e9 h: Q6 t' O# J4 R3 Z2 M    EndOfRoundEvent(wrestler1Deposit,wrestler2Deposit);! Y+ ]3 L3 E# u' H
. F/ K/ ], b& K' ~; G
    }  v& m2 P  Y) M2 d- I

7 y$ K; `( ~2 X    functionendOfGame(addresswinner)internal{5 P5 f! @8 i3 J" h- O) z

6 \4 i0 \/ m8 |8 f- l' [    gameFinished=true;% E1 `& F) R: x/ a

3 P. R' s8 F& u) K$ B* s: x& ~    theWinner=winner;4 B6 g+ e& s4 ^! S; a" M! }
9 f7 H+ C" r; @
    gains=wrestler1Deposit+wrestler2Deposit;
5 y9 j) t% @1 K- U0 e. r8 f5 O
( ?8 g6 l7 B( B1 L3 u, t) A5 @: }    EndOfWrestlingEvent(winner,gains);/ q/ F) i8 v8 [8 V# m( o4 z/ H. @
& O$ E: ^/ x/ J8 o
    }
" k( j/ ^$ e" D. a. [
3 l) k  q1 d9 v    请注意,我们不是直接把钱交给赢家,在此情况下这并不重要,因为赢家会把该合约所有的钱提取出来;而在其他情况下,当多个用户要把合约中的以太币提取出来,使用withdraw模式会更安全,可以避免重入。
, W# X1 A+ u$ @# L- `- T5 {0 L  C1 k4 f- F
    简单地说,如果多个用户都可以从合约中提取资金,那么任谁都能一次性多次调用withdraw函数并多次得到报酬。所以我们需要以这样一种方式来编写我们的取款功能:在他继续得到报酬之前,他应得的数额会作废。1 l( `! r( T7 t7 B4 ~& J! P

  N3 h: W; g3 h4 }: U; O1 b' u    它看起来像这样:: v0 ^1 z4 W3 Z9 e% Y) Q) M* E
: x" H9 A& ^! _5 F
    functionwithdraw()public{  ~, [& P/ g7 ~* K5 ?, F; \
6 h% H1 F9 g, X) t0 G" V
    require(gameFinished&&theWinner==msg.sender);( S  L7 d$ v7 `5 {- N8 l8 A, K" n
5 o  i7 _4 H: A; I
    uintamount=gains;
8 t3 C$ o1 T4 R5 z  P0 v8 J/ ]- n) a! x/ p* w  D
    gains=0;" t0 N: k+ p; b, u. ?7 F6 H7 x, H

0 \4 M1 _" O: m    msg.sender.transfer(amount);
/ e+ u( h$ M$ W3 T) i
# e; A6 ^+ i( o# T    }
- A, h2 n8 Q: y  \, E" w$ B! m4 K( `- I  m* t
    就是这样。你可以在以下链接中找到整个代码段:
7 T: j! I/ x* E) i! S
) _6 F) f) S9 S- b  p% B: F2 `    devzl/ethereum-walkthrough-1
# w: T1 @2 i5 o3 g. p9 H7 U* @4 k5 G6 P5 y0 g
    使用IDE% I) J' x! H( d0 b
6 ^9 {" Z2 H7 j/ D
    现在复制代码段,在浏览器的新标签页中打开RemixIDE:( n8 b" J2 @$ l5 {

0 W$ H/ R$ O! S: n1 v  n    你可以直接在浏览器上使用Remix,它有很多有意思的功能,这些功能你在别的地方几乎找不到。
* i( P% v- v& s4 f+ w. K) T9 @1 f9 |  d% z$ d4 L
    点击页面左上方的“+”按钮,创建一个名为“Wrestling.sol”的新文件,然后粘贴你在上面的github中找到的代码。
) J' C6 ~  @- m" m
6 v! @7 j' n  Q  I- g4 n) I    最后会有一些语法高亮显示。Github暂不支持Solidity.sol扩展。
/ G% c0 v1 P7 E0 J4 y& O! B* t4 ~. R) n( F8 v# @
    在页面的右侧,你可以找到很多有意思的选项卡,比如Analysis,它会显示错误和建议。这个工具留给你好好探索。我还是想向你演示一下,即使在接下来的教程中我们会使用其他的工具。但正如我之前所说的,本系列教程的目标是连接这些信息点并向你展示它们是如何在一起协同工作的,你可以自由决定是否在浏览器上使用IDE。如果你愿意的话,邀请你读一下Remix的文档。+ f+ Y7 P( E2 |) y  L& f4 a
, y1 P7 y4 G5 A3 R
    或者,你可以阅读这些文档来熟悉Solidity。5 N) b8 R5 ]+ l. U( l, f
9 J3 d) W4 X7 D" j
    在接下来的教程中,我们将了解如何将智能合约部署到两种测试网络中,探索truffle,ganache和geth以及它们是如何一起协同工作的。
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

人民干脆面 小学生
  • 粉丝

    0

  • 关注

    0

  • 主题

    9