Hi 游客

更多精彩,请登录!

比特池塘 区块链前沿 正文

以太坊的工作原理

stanstan
71 0 0
不管你们知不知道以太坊(Ethereum blockchain)是什么,但是你们大概都听说过以太坊。最近在新闻里出现过很多次,包括一些专业杂志的封面,但是如果你们对以太坊到底是什么没有一个基本的了解的话,看这些文章就会感觉跟看天书一样。 所以,什么是以太坊?本质上,就是一个保存数字交易永久记录的公共数据库。重要的是,这个数据库不需要任何中央权威机构来维持和保护它。相反的它以一个“无信任”的交易系统来运行—一个个体在不需要信任任何第三方或对方的情况下进行点对点交易的架构。
' L. ^+ s3 s7 C- G) J- i% h  @- b9 Z8 z
依然感到很困惑?这就是这篇文章存在的理由。我的目标是在技术层面来解释以太坊的工作原理,但是不会出现很复杂的数学问题或看起来很可怕的公式。即使你不是一个程序员,我希望你看完之后最起码对技术有个更好的认识。如果有些部分技术性太强不好理解,这是非常正常的,真的没有必要完全理解每一个小细节。我建议只要宏观的理解一下事物就行了。4 p# [  q" I) O# i6 y5 q" {

0 {& [' [' `0 g+ \0 X这篇文章中的很多议点都是以太坊黄皮书中讨论过的概念的细分。我添加了我自己的解释和图表使理解以太坊更加简单一点。那些足够勇敢的人可以挑战一下技术,去阅读一下以太坊的黄皮书。
! r5 e8 d0 ^: d/ C" \$ W, E' i6 b$ E! x; \& W3 r
好了, 让我们开始吧!
& g. y" o* ?! f7 l/ c% d0 `, c' X/ i. b2 v- x+ j
区块链定义
# u" g& @7 w/ O2 v$ p: W& z2 {1 g' C: @: x8 n- }
区块链就是一个具有共享状态的密码性安全交易的单机(cryptographically secure transactional singleton machine with shared-state)。[1]这有点长,是吧?让我们将它分开来看:8 G8 D8 K* G* ]! ?+ P

5 z6 ?! j! j- G5 }! b7 d“密码性安全(Cryptographically secure)”是指用一个很难被解开的复杂数学机制算法来保证数字货币生产的安全性。将它想象成类似于防火墙的这种。它们使得欺骗系统近乎是一个不可能的事情(比如:构造一笔假的交易,消除一笔交易等等)。
/ ^% e0 M: I' a: @. j" S2 j  z1 t. }4 e3 M6 m4 N
“交易的单机(Transactional singleton machine)”是指只有一个权威的机器实例为系统中产生的交易负责任。换句话说,只有一个全球真相是大家所相信的。' Q1 g( @6 w6 P! ?
( `/ p9 E# Z& i4 M1 A
“具有共享状态(With shared-state)”是指在这台机器上存储的状态是共享的,对每个人都是开放的。
' d6 g1 T# R; w7 t' w
/ t% a3 H4 n% z3 p8 |( t' N) [/ B以太坊实现了区块链的这个范例。
: x+ j2 Z& K1 k6 t) B% G, R: j7 n) t& |
以太坊模型说明$ [+ @) f8 V% u) N  {' C) Y# Q

& `) i. ~4 c* I2 |+ e+ [6 m% u6 J以太坊的本质就是一个基于交易的状态机(transaction-based state machine)。在计算机科学中,一个 状态机 是指可以读取一系列的输入,然后根据这些输入,会转换成一个新的状态出来的东西。
9 s5 H0 u7 \- w( R6 U  \% g1 S, s. B, k0 I( j
根据以太坊的状态机,我们从创世纪状态(genesis state)开始。这差不多类似于一片空白的石板,在网络中还没有任何交易的产生状态。当交易被执行后,这个创世纪状态就会转变成最终状态。在任何时刻,这个最终状态都代表着以太坊当前的状态。3 H* U6 c, V) O  n
+ q+ A" m$ e$ x7 S3 r+ N
以太坊的状态有百万个交易。这些交易都被“组团”到一个区块中。一个区块包含了一系列的交易,每个区块都与它的前一个区块链接起来。
' X9 O; F9 T% v  J7 \
. W. g1 [+ r3 E为了让一个状态转换成下一个状态,交易必须是有效的。**为了让一个交易被认为是有效的,它必须要经过一个验证过程,此过程也就是挖矿。**挖矿就是一组节点(即电脑)用它们的计算资源来创建一个包含有效交易的区块出来。
0 m3 L% P+ a1 }8 o! P" P  H4 u2 B& d- O" x. o
任何在网络上宣称自己是矿工的节点都可以尝试创建和验证区块。世界各地的很多矿工都在同一时间创建和验证区块。每个矿工在提交一个区块到区块链上的时候都会提供一个数学机制的“证明”,这个证明就像一个保证:如果这个证明存在,那么这个区块一定是有效的。- O* L) |7 @4 P. N6 F  p8 t

, H) p( K5 Z  _; U+ d2 m为了让一个区块添加到主链上,一个矿工必须要比其他矿工更快的提供出这个“证明”。通过矿工提供的一个数学机制的“证明”来证实每个区块的过程称之为工作量证明(proof of work)。; p* X& J! v* s% l9 v$ ?/ A/ P9 i
! K5 s' x$ N$ x7 w1 p$ |/ ?
证实了一个新区块的矿工都会被奖励一定价值的奖赏。奖赏是什么?以太坊使用一种内在数字代币—以太币(Ether)作为奖赏。每次矿工证明了一个新区块,那么就会产生一个新的以太币并被奖励给矿工。4 E, `9 i; ]5 b# `9 U9 i1 N
+ G, k: f. p- d2 T: i2 s2 {1 }
你也许会在想:什么能确保每个人都只在区块的同一条链上呢?我们怎么能确定不会存在一部分矿工创建一个他们自己的链呢?
! j8 ?, d2 N6 a: d( F4 W3 x5 S! |3 o+ Y  b) g
前面,我们定义了区块链就是一个具有共享状态的交易单机。使用这个定义,我们可以知道正确的当前状态是一个全球真相,所有人都必须要接受它。拥有多个状态(或多个链)会摧毁这个系统,因为它在哪个是正确状态的问题上不可能得到统一结果。如果链分叉了,你有可能在一条链上拥有10个币,一条链上拥有20个币,另一条链上拥有40个币。在这种场景下,是没有办法确定哪个链才是最”有效的“。, |8 x/ J' h" Y; b7 K
0 ~, d$ t7 T* l
不论什么时候只要多个路径产生了,一个”分叉“就会出现。我们通常都想避免分叉,因为它们会破坏系统,强制人们去选择哪条链是他们相信的链。
* r) _3 y8 l) `' A
/ D  `0 {' a" T! v  a6 I4 ]为了确定哪个路径才是最有效的以及防止多条链的产生,以太坊使用了一个叫做“GHOST协议(GHOST protocol)”的数学机制。
6 F5 T' I/ ^0 x7 [
0 r, n4 a2 p( v( D: j+ _GHOST = Greedy Heaviest Observed Subtree
/ w" u" z( }# `  A, n7 u' Q# n
' V5 P2 M; a& m" x. H0 J7 f# [  n/ m8 L9 p简单来说,GHOST协议就是让我们必须选择一个在其上完成计算最多的路径。一个方法确定路径就是使用最近一个区块(叶子区块)的区块号,区块号代表着当前路径上总的区块数(不包含创世纪区块)。区块号越大,路径就会越长,就说明越多的挖矿算力被消耗在此路径上以达到叶子区块。使用这种推理就可以允许我们赞同当前状态的权威版本。
/ K6 e1 V# D' _: {
$ L% [! }! }) r现在你大概对区块链是什么有个理性的认识,让我们在再深入地了解一下以太坊系统主要组成部分:
' [0 Z# t: I, K2 ^
  a. A1 ^, l+ R账户(accounts)
6 k. x/ J: I2 f$ ~4 [& f# V- P0 \7 i( ~. Z# y( j
状态(state)
2 }0 L8 Y; v1 D, ?) T! n4 i
9 h: s0 Q" S1 f  H损耗和费用(gas and fees)
/ {+ O$ C2 t% K8 d$ B3 I
$ f: z& ?- C& M/ X7 h/ T6 j# j3 X7 h6 M交易(transactions)
2 \  _  c: R& v2 }
* R3 }7 k  u- i9 p' ?7 s区块(blocks)( c' W! H$ h* a5 q( G& ]
* A/ O- s3 h, g# M
交易执行(transaction execution), p( s' e: b  O  }
& h4 ^8 g# ]/ p9 S3 N" z
挖矿(mining)
0 l6 q0 }  F+ ^  i: z9 O3 o% [9 H4 V: d( F
工作量证明(proof of work)  a/ B! [8 K# \3 `- S

" W3 Y, p7 t! K# t在开始之前需要注意的是:每当我说某某的Hash, 我指的都是KECCAK-256 hash, 以太坊就是使用这个Hash算法。% ?: g# w4 P) r4 v1 Z5 e
- z$ d! f8 E2 G, m0 q/ g* @/ x
账户
) }( P. N  m2 c' x
" B' b7 K: y, ^! k' Y7 M) J5 N( j* F8 q以太坊的全局“共享状态”是有很多小对象(账户)来组成的,这些账户可以通过消息传递来与对方进行交互。每个账户都有一个与之关联的状态(state)和一个20字节的地址(address)。在以太坊中一个地址是160位的标识符,用来识别账户。
6 m, a: \4 ~0 w( q* C. ~% J
- W  r5 O6 h* j8 G4 l两种不同类型的账户:
: j& h- q4 W8 g% i+ l( A4 R9 E9 p7 ^3 J7 v' t7 L6 ^
外部拥有的账户,被私钥控制且没有任何代码与之关联
. w& o; T* l( ^
& Q6 o  P! f6 c- b合约账户,被它们的合约代码控制且有代码与之关联! I5 b! `0 y1 J4 l

" P# P! m8 t7 |4 ^5 [外部拥有账户与合约账户的比较
8 l1 G6 @* V6 [4 M4 Z- }- B! M' I: u
理解外部拥有账户和合约账户的基本区别是很重要的。一个外部拥有账户可以通过创建和用自己的私钥来对交易进行签名,来发送消息给另一个外部拥有账户或合约账户。在两个外部拥有账户之间传送的消息只是一个简单的价值转移。但是从外部拥有账户到合约账户的消息会激活合约账户的代码,允许它执行各种动作。(比如转移代币,写入内部存储,挖出一个新代币,执行一些运算,创建一个新的合约等等)。
: G. ~+ l7 [9 U- {  |/ B4 `' K& p4 S
& D  n; T8 U; x" ]1 q不像外部拥有账户,合约账户不可以自己发起一个交易。相反,合约账户只有在接收到一个交易之后(从一个外部拥有账户或另一个合约账户处),为了响应此交易而触发一个交易。我们将会在“交易和消息”章节来了解关于合约与合约之间的通信。2 {$ k$ o+ n1 `  C
9 A; @  r  m' |3 |: ]4 F, X
因此,在以太坊上任何的动作,总是被外部拥有账户触发的交易所发动的。
6 l6 a' I; i$ Q  ^+ y6 \9 w- }* `$ ^& M4 u2 p. N; ]
账户状态
: p& `- ]8 E) U1 a
& J" |* ~5 y$ r3 c& A: G/ e账户状态有四个组成部分,不论账户类型是什么,都存在这四个组成部分:, ~! Z) p+ s4 H# {
8 ?9 A  ~9 J% f; L1 v. _7 q
nonce:如果账户是一个外部拥有账户,nonce代表从此账户地址发送的交易序号。如果账户是一个合约账户,nonce代表此账户创建的合约序号
: Q9 h" Y' _8 x5 d4 e" v8 j+ X% y% X5 ?# X8 Y/ e1 [
balance: 此地址拥有Wei的数量。1Ether=10^18Wei- n& Z0 n$ i8 q' {: Y% D  X

1 ]3 x5 J  k! Y- U' B; c6 {, x( zstorageRoot: Merkle Patricia树的根节点Hash值(我们后面在解释Merkle树)。Merkle树会将此账户存储内容的Hash值进行编码,默认是空值) ]; Y5 g7 @/ }5 {( g# T% I- t
$ i$ D: W$ I6 [) O
codeHash:此账户EVM(以太坊虚拟机,后面细说)代码的hash值。对于合约账户,就是被Hash的代码并作为codeHash保存。对于外部拥有账户,codeHash域是一个空字符串的Hash值0 y& w: R' t9 g+ e/ T9 o+ r1 d

1 [6 y' k* B: c2 f$ Y1 z世界状态
  L, J" a; `  k4 j) u& c; |' R# Z
% V3 L' d" |+ R$ S& r好了,我们知道了以太坊的全局状态就是由账户地址和账户状态组成的一个映射。这个映射被保存在一个叫做Merkle Patricia树的数据结构中( {, g+ o" h1 o, ]

4 r8 q4 \- y5 g; [Merkle Tree(也被叫做Merkle trie)是一种由一系列节点组成的二叉树,这些节点包括:" j. c0 l7 W7 ]4 O" r0 I

4 C  k8 B4 j  Q5 V& i在树底的大量叶子节点,这些叶子节点包含了源数据4 c$ Y8 i' a1 X( W: h6 ?+ n5 a

$ w" U0 Z7 y$ O2 a" E( B一系列的中间节点,这些节点是两个子节点的Hash值
7 O$ W$ @8 f3 k" g% n- s1 R3 @, y% P" V* V
一个根节点,同样是两个子节点的Hash值,代表着整棵树2 ?" w3 b* G, U, d! M" n

" O" T! O% E! ]* ]* x# G树底的数据是通过分开我们想要保存到chunks的数据产生的,然后将chunks分成buckets,再然后获取每个bucket的hash值并一直重复直到最后只剩下一个Hash:根Hash。
7 L' T, a- }7 I# z
% N1 M) a2 x0 G这棵树要求存在里面的值(value)都有一个对应的key。从树的根节点开始,key会告诉你顺着哪个子节点可以获得对应的值,这个值存在叶子节点。在以太坊中,key/value是地址和与地址相关联的账户之间状态的映射,包括每个账户的balance, nonce, codeHash和storageRoot(storageRoot自己就是一颗树)。& p7 l% m7 Q3 ]( s+ P+ w

9 X" M. k4 c4 ~: R: h+ q; b  C同样的树结构也用来存储交易和收据。更具体的说,每个块都有一个头(header),头中保存了三个Merkle树结构的根节点Hash,三个Merkle树分别为:6 s+ b9 y8 A# x( p  D, T
. I* c/ h. h3 `3 P' |1 a: R
状态树
, y/ S9 c, R$ ^/ m5 Z
9 L, z7 `6 _6 G; L( J交易树/ R' J  P! m0 J% J- |
5 q3 x( X3 }% N9 C( ]1 y
收据树
$ B0 P" S$ w' i0 c
$ M, \- j3 j8 |/ H5 j% c, R2 ^Merkle树中存储信息的高效性在以太坊的“轻客户端”和“轻节点”中相当的有用。记住区块链就是一群节点来维持的。广泛的说,有两种节点类型:全节点和轻节点。' e- J! q$ P5 K. X" h6 E
; T" M; i( e: b) }
全节点通过下载整条链来进行同步,从创世纪块到当前块,执行其中包含的所有交易。通常,矿工会存储全节点,因为他们在挖矿过程中需要全节点。也有可能下载一个全节点而不用执行所有的交易。无论如何,一个全节点包含了整个链。% ^# O# N" x1 a& S  y# J) B2 H

& s! n. [9 l( f/ u7 K" v3 P不过除非一个节点需要执行所有的交易或轻松访问历史数据,不然没必要保存整条链。这就是轻节点概念的来源。比起下载和存储整个链以及执行其中所有的交易,轻节点仅仅下载链的头,从创世纪块到当前块的头,不执行任何的交易或检索任何相关联的状态。由于轻节点可以访问区块头,而头中包含了3个Merkle树的根Hash值,所有轻节点依然可以很容易生成和接收关于交易、事件、余额等可验证的答案。; l: w9 r3 q9 h) d

" t7 m% s9 C- X) ^这个可以行的通是因为在Merkle树中Hash值是向上传播的—如果一个恶意用户试图用一个假交易来交换Merkle树底的交易,这个会改变它上面节点的Hash值,而它上面节点的值的改变也会导致上上一个节点Hash值的改变,以此类推,一直到树的根节点。- h, E* j+ r! Y8 z- ^, e

( L6 {& _1 \5 d/ u$ c, }) d0 A0 ^任何节点想要验证一些数据都可以通过Merkle证明来进行验证,Merkle 证明的组成:+ W: P' L# f; y( ]6 [

3 v+ M$ I/ G1 O- D一块需要验证的数据# w! x3 A' E. [( g
- o0 n; K0 J# }# |$ L7 d
树的根节点Hash值
7 s5 y# _) `% k% X$ k' z. ?
5 }8 {2 X8 @" F' V4 w一个“分支”(从 chunk到根这个路径上所有的Hash值)* R" M9 K, V& a

3 w  L% U+ E% I6 s$ a3 P任何可以读取证明的人都可以验证分支的Hash值是连贯的,因此给出的块在树中实际的位置就是在此处。
* Z7 p1 H" i. n' a% |; E7 k/ N/ ^0 y7 m5 K; {7 N
总之,使用Merkle Patricia树的好处就是该结构的根节点加密取决于存储在树中的数据,而且根节点的Hash值还可以作为该数据的安全标识。由于块的头包含了状态树、交易树、收据树的根Hash值,所以任何节点都可以验证以太坊的一小部分状态而不用保存整个状态,这整个状态的的大小可能是非常大的。8 C. A/ d; p- [

: J  O% k$ K  K; x" VGas和费用1 r% R, \% R+ H8 V/ \4 g! H! R
; F+ ?* }% u' d; }! t" r# Z
在以太坊中一个比较重要的概念就是费用(fees),由以太坊网络上的交易而产生的每一次计算,都会产生费用—没有免费的午餐。这个费用是以”gas”来支付。- r( [* l' F! M# t. C
" i1 R" d% S& k
Gas就是用来衡量在一个具体计算中要求的费用单位。gas price就是你愿意在每个gas上花费Ether的数量,以“gwei”进行衡量。“Wei”是Ether的最小单位,1Ether=10^18Wei,1gwei=1,000,000,000 Wei。
9 y. ~$ V- D9 }. L  Z3 ?/ u* b5 i" ], C+ H* F; T
对每个交易,发送者设置gas limit和gas price。gas limit和gas price就代表着发送者愿意为执行交易支付的Wei的最大值。
& |  D8 x' o% v2 [$ I1 V
/ D# S" c6 b0 g6 X  V! O2 U例如,假设发送者设置gas limit为50,000,gas price为20gwei。这就表示发送者愿意最多支付50,000*20gwei = 1,000,000,000,000,000 Wei = 0.001 Ether来执行此交易。- D+ E: U! S9 m9 j- I) f7 k
# n' g0 l- B) y) ]8 T' n
记住gas limit代表用户愿意花费在gas上费用的最大值。如果在他们的账户余额中有足够的Ether来支付这个最大值费用,那么就没问题。在交易结束时任何未使用的gas都会被返回给发送者,以原始费率兑换。
: J' }* N" [. K. ]( i' X% x! j) p% z. t% z! k
在发送者没有提供足够的gas来执行交易,那么交易执行就会出现“gas不足”然后被认为是无效的。在这种情况下,交易处理就会被终止以及所有已改变的状态将会被恢复,最后我们就又回到了交易之前的状态—完完全全的之前状态就像这笔交易从来没有发生。因为机器在耗尽gas之前还是为计算做出了努力,/ H* e4 \! A+ x' l4 H

0 p! z3 E8 H. O# _所以理论上,将不会有任何的gas被返回给发送者。
7 ?7 y- r( L) l' }" I0 Y8 C; o9 o$ e' p: I
这些gas的钱到底去了哪里?发送者在gas上花费的所有费用都被发送到“受益人”的地址,通常情况下就是矿工的地址。因为矿工为了计算和验证交易做出了努力,所以矿工接收gas的费用作为奖励。8 _0 @: T; q: Y1 p7 t2 _

, f: t2 i+ s$ O: [通常,发送者愿意支付更高的gas price,矿工从这笔交易中就能获得更多的价值。因此,矿工也就更加愿意选择这笔交易。这样的话,矿工可以自由的选择自己愿意验证或忽略的交易。为了引导发送者设置合理的gas price,矿工可以选择建议一个最小的gas值,此值代表自己愿意执行交易的最低价格。
, B, U5 S" ]6 o6 T" j$ U
0 ~8 L& `2 N$ u* d" [" K# V. e存储也有费用
" k- n, S. E' ]8 L# Z# U
# K+ c/ L& j7 F0 z+ C8 ]) \Gas不仅仅是用来支付计算这一步的费用,而且也用来支付存储的费用。存储的总费用与所使用的32位字节的最小倍数成比例。3 `: d" y, w: H0 [/ p8 n

) k2 D* \$ l- @6 o% D, c, Q存储费用有一些比较细微的方面。比如,由于增加的存储增加了所有节点上的以太坊状态数据库的大小,所以激励保持数据存储量小。为了这个原因,如果一个交易的执行有一步是清除一个存储实体,那么为执行这个操作的费用就会被放弃,并且由于释放存储空间的退款就会被返回给发送者。
/ X: P: [3 u4 O/ h  O( ?& G9 g& A: d4 x* q/ X% S8 u; B% a# l
费用的作用是什么?7 s" ^, k6 \! O( _4 m, ]
7 Y3 M; F2 f+ M: O9 \& H' `
以太坊可以运作的一个重要方面就是每个网络执行的操作同时也被全节点所影响。然而,计算的操作在以太坊虚拟机上是非常昂贵的。因此,以太坊智能合约最好是用来执行最简单的任务,比如运行一个简单的业务逻辑或者验证签名和其他密码对象,而不是用于复杂的操作,比如文件存储,电子邮件,或机器学习,这些会给网络造成压力。施加费用防止用户使网络超负荷。
, H: g* ^( u5 h$ B  B% y0 d
2 V; E! P4 T$ c5 \以太坊是一个图灵完备语言(短而言之,图灵机器就是一个可以模拟任何电脑算法的机器。对于图灵机器不太熟悉的人可以看看这个 和这个 )。这就允许有循环,并使以太坊受到停机问题 的影响,这个问题让你无法确定程序是否无限制的运行。如果没有费用的话,恶意的执行者通过执行一个包含无限循环的交易就可以很容易的让网络瘫痪而不会产生任何反响。因此,费用保护网络不受蓄意攻击。
! U$ M5 i! f0 d. v6 y  c: Q9 \3 Q. }* M; [
你也许会想,“为什么我们还需要为存储付费?”其实就像计算一样,以太坊网络上的存储是整个网络都必须要负担的成本。- r. B% }: B. l: h7 I7 j  |! x

5 ?- W, i- M7 C7 g交易和消息
6 ?2 v$ R* X! z; P& i  K3 L' [3 _# |  f; a. E
之前说过以太坊是一个基于交易的状态机。换句话说,在两个不同账户之间发生的交易才让以太坊的全局状态从一个状态转换成另一个状态。
# @  u3 S1 l  n
/ K  ^3 U$ e0 A最基本的概念,一个交易就是指被外部拥有账户生成的加密签名的一段指令,序列化之后提交给区块链。
5 @, X: Q/ k! n: X# e/ |% T" D
有两种类型的交易:消息通信(message calls)和合约创建(contract creations)(也就是交易产生一个新的以太坊合约)。
- @% v$ s( Y. w
, }0 m+ ?4 ~5 j# j! p) M* |2 ]不管什么类型的交易,都包含:0 c; _2 O% I& \- x% R

) ?; b* k# r: bnonce:发送者发送交易数的计数2 a' }" E% Q# G& x0 Q& U
* |( |6 Y# \3 X
gasPrice:发送者愿意支付执行交易所需的每个gas的Wei数量
& x  B6 G5 B+ q' O( P4 c- N% P  q8 w. o3 ^: a
gasLimit:发送者愿意为执行交易支付gas数量的最大值。此值设置之后在任何计算完成之前就会被提前扣掉
6 F& _$ v3 G) U' J
- s$ F; ]0 B* r" x& v; nto:接收者的地址。在合约创建交易中,合约账户的地址还没有存在,所以值先空着+ U& G0 V8 o- i1 u, ?

, E+ }1 u$ ^0 f7 l4 x% Yvalue:从发送者转移到接收者Wei的数量。在合约创建交易中,value作为新建合约账户的开始余额3 l9 _! ?- P: M8 E" R

. y- }% ^9 J* P9 wv,r,s:用于产生标识交易发送者的签名1 V7 ~+ ~0 }: W2 d, {, s$ o

- {' [! N' A8 T  p$ Binit(只有在合约创建交易中存在):用来初始化新合约账户的EVM代码片段。init值会执行一次,然后就会被丢弃。当init第一次执行的时候,它返回一个账户代码体,也就是永久与合约账户关联的一段代码。, o) s/ J  h5 h) \) p. j: D* Q8 N
# V) s" d1 g* Z* V# K7 t8 K7 ]& w
data(可选域,只有在消息通信中存在):消息通信中的输入数据(也就是参数)。例如,如果智能合约就是一个域名注册服务,那么调用合约可能就会期待输入参数:域名和IP地址0 ~  v9 l' G/ c7 v6 `

  d3 s& s/ b7 U3 c" ]! O1 J+ n. B在“账户”这个章节中我们学到交易—消息通信和合约创建交易两者都总是被外部拥有账户触发并提交到区块链的。换种思维思考就是,交易是外部世界和以太坊内部状态的桥梁4 l/ |# {+ D( O- N

* P8 m, v7 E' Y: K6 ?- h! j( w) ~) _但是这也并不代表一个合约与另一个合约无法通信。在以太坊状态全局范围内的合约可以与在相同范围内的合约进行通信。他们是通过“消息”或者“内部交易”进行通信的。我们可以认为消息或内部交易类似于交易,不过与交易有着最大的不同点—它们不是由外部拥有账户产生的。相反,他们是被合约产生的。它们是虚拟对象,与交易不同,没有被序列化而且只存在于以太坊执行环境。
3 \7 G7 e) J2 s9 U/ p. L
! V* Q+ I* }2 E1 ~) N当一个合约发送一个内部交易给另一个合约,存在于接收者合约账户相关联的代码就会被执行。& M) U2 T1 M7 v" @" ~: N

& q; M- u. q6 F7 g- j7 F1 v一个需要注意的重要事情是内部交易或者消息不包含gasLimit。因为gas limit是由原始交易的外部创建者决定的(也就是外部拥有账户)。外部拥有账户设置的gas limit必须要高到足够将交易完成,包括由于此交易而产生的任何”子执行”,例如合约到合约的消息。如果,在一个交易或者信息链中,其中一个消息执行造成gas不足,那么这个消息的执行会被还原,包括任何被此执行触发的子消息。不过,父执行没必要被还原9 J1 Q* x% w% u) X% Q3 }; s
; |- S5 i) s' Y( O* P) [) ?# h
区块" C$ n4 X* V- |4 w
" l0 F( G% w$ z+ v3 m& k
所有的交易都被组成一个”块”。一个区块链包含了一系列这样链在一起的区块。5 s2 G  x% O, ?- S' ~# D* {/ Q% d

; H  e+ Y1 V5 A1 x9 B在以太坊中,一个区块包含:
+ g2 W  p" f" t: X7 c( N+ B
3 o( L) b2 G6 M: m: X区块头
- _5 H) @0 M4 {4 {- {  ^5 w' H9 C9 d8 g1 u9 z
关于包含在此区块中交易集的信息+ P3 i' n: L4 P9 n1 r6 b

) W- u& p0 g' y8 Z与当前块的ommers相关的一系列其他区块头8 h! R8 h9 V* Q1 U
6 b" n" C8 V; P! ?$ u7 q- ~
Ommers解释. K4 P4 {* f) L; j
; s4 W) _5 K3 X7 v
“ommer”到底是什么? ommer就是一个区块的父区块与当前区块父区块的父区块是相同的。让我们快速了解一下ommers是用来干嘛的,并且为什么一个区块需要为ommers包含区块头。
& h$ `# Q' P- r$ c2 L
" {7 c: x7 r! x3 f4 y/ n由于以太坊的构造,它的区块生产时间(大概15秒左右)比其他的区块链例如Bitcoin(大概10分钟左右)要快很多。这使得交易的处理更快。但是,更短的区块生产时间的一个缺点就是:更多的竞争区块会被矿工发现。这些竞争区块同样也被称为“孤区块”(也就是被挖出来但是不会被添加到主链上的区块)。
* ]( N0 B$ u, L4 Z% @: V3 F( v: M7 x6 F$ l) L1 Z# m
Ommers的目的就是为了帮助奖励矿工纳入这些孤区块。矿工包含的ommers必须是有效的,也就是ommers必须是往上数6代之内或更小范围内父区块的子区块。 一个孤区块在第6个子区块之后,这种陈旧的孤区块将不会再被引用(因为包含老旧的交易会使事情变得复杂一点)。& \( |  a7 A+ Y% v1 W

  S( Q: {, v& O& K& M% |# Y8 SOmmer区块会收到比全区块少一点的奖励。不管怎样,依然存在激励来让矿工们纳入孤区块并能从中获得一些报酬。
0 f2 E; f4 H1 j" e: h
/ s7 @$ Q8 H. i. @8 Z& l区块头
0 a% V1 c4 A, {' l) s/ K" g+ x4 x- W, h: g1 _8 J& Z2 o
让我们再回到区块的问题上。我们前面提到每个区块都有一个“区块头”,但这究竟是什么?% H, v6 f& ]! D! w) F2 f
& a2 V$ N2 v9 W$ ]; L$ n# Q' x
区块头是区块的一部分,包含了:% G/ l& G+ `4 l! b

$ R' b7 ?# J: v" CparentHash:父区块头的Hash值(这也是使得区块变成区块链的原因)
2 q# b0 g5 v) D) C# m7 d, Y2 J' R8 Z+ R" C( y
ommerHash:当前区块ommers列表的Hash值
/ ^; P" ~8 m3 `8 [# }  N
4 H5 S) [5 |; m, E* E" K1 Sbeneficiary:接收挖此区块费用的账户地址
2 G# \/ N: {$ M2 X2 B3 m; @& ?& Q/ Q6 B" `( b! c. ^
stateRoot:状态树根节点的Hash值(回忆一下我们之前所说的保存在头中的状态树以及它使得轻客户端认证任何关于状态的事情都变得非常简单)/ W3 y/ y/ i# `5 @, @# [2 \
/ \+ K5 u# t& F: R. E8 H  N/ b0 R
transactionsRoot:包含此区块所有交易的Merkle树的根节点Hash值
' p9 p, j* {; {0 W( T3 N
- @" S/ D1 H5 treceiptsRoot:包含此区块所有交易收据的Merkle树的根节点Hash值% i; J+ G- P' p; ~

( k" n$ x* J$ nlogsBloom:由日志信息组成的一个Bloom过滤器 (一种数据结构)/ D4 ?  N) ]$ g7 F. `

% o* D3 \1 l% |. t" m' h# }( Q7 odifficulty: 此区块的难度级别
$ C' F0 G/ f; c# I5 S; \, S* x1 Z; Y" p8 W
number:当前区块的计数(创世纪块的区块序号为0,对于每个后续区块,区块序号都增加1)& \$ g7 w8 \" |1 [

& T8 X* w8 S* d3 L- r, P$ k  J4 WgasLimit:每个区块的当前gas limit
8 h  o: K( o7 Z
- c* {  J  @4 u% ggasUsed: 此区块中交易所用的总gas量
, B4 A2 d2 K. E9 R, |2 P+ T; r9 G& s3 a4 x- p7 m& c1 v
timestamp:此区块成立时的unix的时间戳
  h! K  @# s( v4 `; D
0 G7 i- k, T% k" vextraData:与此区块相关的附加数据
+ m: V0 X7 i( A1 v  g/ O! I! y" I- o- e1 F% C
mixHash:一个Hash值,当与nonce组合时,证明此区块已经执行了足够的计算: @7 B5 O6 ~2 P# q# J7 L' n
; n/ O5 b( X- ^$ S5 H
nonce:一个Hash值,当与mixHash组合时,证明此区块已经执行了足够的计算& {! k4 J; q" z4 v
& a: e- b( q# E* F
注意每个区块是如何包含三个树结构的,三个树结构分别对应:
9 U" M( k& j+ P/ ~/ q% ?
6 x5 H( l: a2 R) G" R状态(stateRoot)9 t7 r. g4 u* U& f5 `$ |: z  }

0 I2 Z  n, q, z( d$ l交易(transactionsRoot)# ]& m9 X- H, N6 m, I
/ w) A+ f( x- B' P# S0 Z
收据(receiptsRoot)6 |( a, o) g1 }9 x

" {- Q- [' p, n/ E% O/ x/ S% f这三个树结构就是我们前面讨论的Merkle Patricia树。
, {: @& F1 `7 O! O# \+ [/ [; X, y$ X5 Y
另外,上面描述的有几个术语值得说明一下,下面来看一下。5 |: c8 p( F* t. a& {: Q; i

! U1 \& ?1 q9 L3 g- V. `. |, ~! H" A日志9 K( }2 y( a( \5 N1 I/ S3 S
1 g: V4 p# G$ z0 L, O) a
以太坊允许日志可以跟踪各种交易和信息。一个合约可以通过定义“事件”来显示的生成日志。
/ {1 L* Q# j6 f* \3 Y# l2 U) [
* p' X! Y4 v6 q- V一个日志的实体包含:* f3 [, I' m- f7 N
3 |0 v3 d0 V" Z3 m$ w3 a8 O8 d
记录器的账户地址
3 Q# H2 d  J- T0 p9 _2 `; t9 D$ Z! \
代表本次交易执行的各种事件的一系列主题以及与这些事件相关的任何数据
! h$ W; Y0 |  [0 r
, J' U0 [) t6 N( O  m6 N日志被保存在bloom过滤器 中,过滤器高效的保存了无尽的日志数据。" L2 E) z( ?7 m' p  `1 m: f
# u7 y5 b& P; J
交易收据
6 E0 Z8 B$ B- {6 X! G0 b6 N$ ]0 }' l9 W" a0 ~( {: J
包含着日志信息的交易收据的根Hash值保存在头中。 就像你在商店买东西时收到的收据一样,以太坊为每笔交易都产生一个收据。像你期望的那样,每个收据包含关于交易的特定信息,这些信息为:! E8 F& ?: e% A7 k6 [# p" H* ?9 W

& j0 n+ z5 o5 L# d6 C2 B区块序号4 z. e% M4 s/ H
) C1 `: {% D3 c" l. A. K/ v/ }
区块Hash值* L% g0 P& m6 H4 Z8 T0 t7 I( @. X3 q

/ X* q/ l+ m+ D! O1 m交易Hash值
/ T2 E- `5 L: @6 e  x& ?
5 x8 `; z/ E1 I1 n当前交易使用了的gas
4 p, R6 ~0 ^. T& i* o$ }: h. ^0 m+ q) i9 t
在当前交易执行完之后当前块使用的累计gas8 m# @' q9 U' ?# b" ~- C
& u) X. I3 f, X/ F; l
执行当前交易时创建的日志
3 z7 Z& l/ J9 k
6 c, z/ A/ k. D  J等等+ Z4 ^4 X% i8 N% z  S+ |; i
" Q$ q6 n' M9 `" m& R
区块难度% e' {1 w4 }9 f* H
, K  T( U  r2 D7 a! d' T
区块的难度是被用来在验证区块时加强一致性。创世纪区块的难度是131,072,有一个特殊的公式用来计算之后的每个块的难度。如果某个区块比前一个区块验证的更快,以太坊协议就会增加区块的难度。7 `4 d* c, ~9 u) V" t

6 R) i1 E4 I; j( v4 S9 G) X区块的难度影响nonce,它是在挖矿时必须要使用工作量证明算法计算出的一个Hash值。
# H, c" a' B7 O$ }, D8 c8 A8 S; O: b/ a! f8 b
区块难度和nonce之间的关系用数学形式表达就是:
3 S! @: J! v3 p; @+ S3 g8 o3 b6 Z6 l, Q2 I
Hd代表的是难度。# O/ N+ D$ v9 i- |) @. `
: L5 N( ~9 a6 H! ^( E
找到符合难度阈值的nonce唯一方法就是使用工作量证明算法来列举所有的可能性。找到解决方案预期时间与难度成正比—难度越高,找到nonce就越困难,因此验证一个区块也就越难,这又相应地增加了验证新块所需的时间。所以,通过调整区块难度,协议可以调整验证区块所需的时间。
1 f8 _( x( Z# i' o
- v+ e7 T% q% O+ P* G8 h+ a) `另一方面,如果验证时间变的越来越慢,协议就会降低难度。这样的话,验证时间自我调节以保持恒定的速率—平均每15s一个块。: K8 e: I) Z) ~1 t: M' E& d5 X

+ r( M+ i4 J/ J交易执行# [& j6 Z3 E% b9 P) M5 q2 w
# D  l% I) V" @' T+ P+ }$ {" s  O
我们已经到了以太坊协议最复杂的部分:交易的执行。假设你发送了一笔交易给以太坊网络处理,将以太坊状态转换成包含你的交易这个过程到底发生了什么?4 N) E7 r' K, p- a+ H

, ]4 P5 R2 R6 I' b( G首先,为了可以被执行所有的交易必须都要符合最基础的一系列要求,包括:
8 c9 X3 o" A7 I, W& u$ u7 ~1 c1 C
2 u  K1 ]8 ]5 a/ w( E5 C) H交易必须是正确格式化的RLP。”RLP”代表Recursive Length Prefix,它是一种数据格式,用来编码二进制数据嵌套数组。以太坊就是使用RLP格式序列化对象。8 @# q; R: t9 z: ]6 `

, V) H& u+ e( x/ n有效的交易签名。
4 u+ S4 _. w* K: y# d( p( \% {4 W( i' M: L
有效的交易序号。回忆一下账户中的nonce就是从此账户发送出去交易的计数。如果有效,那么交易序号一定等于发送账户中的nonce。
( F2 _; ]% `; n5 d- ?3 X: e" T0 L/ T- [. u8 Z" g6 g- g# `
交易的gas limit 一定要等于或者大于交易使用的intrinsic gas,intrinsic gas包括:7 l  P' A5 C* Q# z! k- q( m
  S9 E* q9 a0 t. A0 T9 x
1.执行交易预订费用为21,000gas' A1 ?* g/ Q4 J

) f* F$ _0 n+ l4 S0 J3 C/ t4 L2.随交易发送的数据的gas费用(每字节数据或代码为0的费用为4gas,每个非零字节的数据或代码费用为68gas)4 k5 \! ~' O7 H3 @* v* M
9 v! H( v" {* A$ s$ u. B
3.如果是合约创建交易,还需要额外的32,000gas
( z: ~; f# @; q, u* N' w) h
* U7 Q# O- e+ C2 F/ Y- x发送账户余额必须有足够的Ether来支付”前期”gas费用。前期gas费用的计算比较简单:首先,交易的gas limit乘以交易的gas价格得到最大的gas费用。然后,这个最大的gas费用加上从发送方传送给接收方的总值。
6 }) E  l0 ~9 ^* U
/ d5 x) r9 P, A3 R7 e' I- P如果交易符合上面的所有要求,那么我们进行下面的步骤。1 D* S& t. w% B/ t

5 s8 r, z' F, V& g  [5 u第一步,我们从发送者的余额中扣除执行的前期费用,并为当前交易将发送者账户中的nonce增加1。此时,我们可以计算剩余的gas,将交易的总gas减去使用的intrinsic gas。1 l4 W7 u" I" Y6 t8 _

5 {1 [* i! f  z7 K3 \第二步,开始执行交易。在交易执行的整个过程中,以太坊保持跟踪“子状态”。子状态是记录在交易中生成的信息的一种方式,当交易完成时会立即需要这些信息。具体来说,它包含:
( q, `# _' P) t9 Q# z  ~) g2 ^  Y
0 e7 Z" V* H2 T+ ]自毁集:在交易完成之后会被丢弃的账户集(如果存在的话)3 z8 {* \$ T) t4 `7 U2 q& i& M
1 A1 K2 X/ Z# a) c
日志系列:虚拟机的代码执行的归档和可检索的检查点
. ^! @8 a7 B' f% ]# Z  X, P
# }6 F4 }, v$ u, E4 N- ]: N退款余额:交易完成之后需要退还给发送账户的总额。回忆一下我们之前提到的以太坊中的存储需要付费,发送者要是清理了内存就会有退款。以太坊使用退款计数进行跟踪退款余额。退款计数从0开始并且每当合约删除了一些存储中的东西都会进行增加。
" x, \$ q, Z6 z. j% P" f4 S' z# R$ b) y) g
第三步,交易所需的各种计算开始被处理。
0 t" v- _: l8 o. ^5 m$ I; S! T# H, Z0 z" T& S
当交易所需的步骤全部处理完成,并假设没有无效状态,通过确定退还给发送者的未使用的gas量,最终的状态也被确定。除了未使用的gas,发送者还会得到上面所说的“退款余额”中退还的一些津贴。8 R1 Z5 o1 I/ `2 R) N% A# a0 ~

; H9 x6 Z$ A: P; c一旦发送者得到退款之后:
6 E. a8 e1 S4 E$ _! m) }
3 |1 j/ Q  s& k$ @- h( ^gas的Ether就会给矿工0 S# b" H- i4 d

* f( Y1 d7 S' c/ L1 c交易使用的gas会被添加到区块的gas计数中(计数一直记录当前区块中所有交易使用的gas总量,这对于验证区块时是非常有用的)
  p) G7 v& |# L1 T( h( ]3 V2 m" V$ Z
所有在自毁集中的账户(如果存在的话)都会被删除, l, o8 Q1 v3 W
7 ~- T% e7 B9 ^8 L) q2 i* a( q
最后,我们就有了一个新的状态以及交易创建的一系列日志。
9 J8 P: p% \* h3 a$ P; |7 C( }1 ?' {" b( w' a$ v+ \; I# n, f  p
现在我们已经介绍了交易执行的基本知识,让我们再看看合约创建交易和消息通信的一些区别。
% i3 C* [/ J* G* {( Q( ]4 @. |6 g0 J) C; j  E
合约创建(Contract creation)9 n4 ]% \- @3 q9 f
5 T% S; h# d) i+ L0 m0 o6 r
回忆一下在以太坊中,有两种账户类型:合约账户和外部拥有账户。当我们说一个交易是“合约创建”,是指交易的目的是创建一个新的合约账户。
$ p, X+ E8 m7 \$ B: f4 ~# z
* r( @- l/ h) I- m( c为了创建一个新的合约账户,我们使用一个特殊的公式来声明新账户的地址。然后我们使用下面的方法来初始化一个账户:
: A1 D( ^5 I! [
- W6 d) ^" p. U/ {+ S设置nonce为0
; F6 h5 J4 g- w% y. f# A  k; x4 @9 ^* k7 w% }
如果发送者通过交易发送了一定量的Ether作为value,那么设置账户的余额为value) F6 p% S% d0 Z5 O3 \
  h, r; n( j+ a0 W& o7 |. p& H
将存储设置为0
6 Q6 f: A( i2 v. ?
: W  J# z9 C6 c" L. J/ Y设置合约的codeHash为一个空字符串的Hash值
+ b# }( E* c) a
7 H5 L0 o. m2 o" [一旦我们完成了账户的初始化,使用交易发送过来的init code(查看”交易和消息”章节来复习一下init code),实际上就创造了一个账户。init code的执行过程是各种各样的。取决于合约的构造器,可能是更新账户的存储,也可能是创建另一个合约账户,或者发起另一个消息通信等等。4 y# q1 n; Q' R' T- N/ M

1 n8 O7 h; `9 a& d当初始化合约的代码被执行之后,会使用gas。交易不允许使用的gas超过剩余gas。如果它使用的gas超过剩余gas,那么就会发生gas不足异常(OOG)并退出。如果一个交易由于gas不足异常而退出,那么状态会立刻恢复到交易前的一个点。发送者也不会获得在gas用完之前所花费的gas。
! g- l6 T7 {- w. B" ]- U- d0 `3 r" O2 t
不过,如果发送者随着交易发送了Ether,即使合约创建失败Ether也会被退回来。* _- h( m5 \; E! x1 r

. |% `' A( h8 O- \如果初始化代码成功的执行完成,最后合约创建的花费会被支付。这些是存储成本,与创建的合约代码大小成正比(再一次,没有免费的午餐)。如果没有足够的剩余gas来支付最后的花费,那么交易就会再次宣布gas不足异常并中断退出。9 f7 c9 H+ G0 O0 {2 a4 ?' A  p. i) Z$ H
0 X2 s# W. `2 e5 b* ^" z6 F8 U5 k4 m
如果所有的都正常进行没有任何异常出现,那么任何剩余的未使用gas都会被退回给原始的交易发送者,现在改变的状态才被允许永久保存。
9 O- R8 G) T" R( }9 Q' {
( e8 \+ o6 k8 M8 I+ [/ ?消息通信(Message calls)' F  L& |5 A8 l, Y8 r; s/ t

9 q# a) P+ \6 ~. S5 N) J6 p1 s4 L* C消息通信的执行与合约创建比较类似,只不过有一点点区别。( k- B, e/ y6 `3 q- ^2 d
  O$ L* o6 v; `5 l# \) H
由于没有新账户被创建,所以消息通信的执行不包含任何的init code。不过,它可以包含输入数据,如果交易发送者提供了此数据的话。一旦执行,消息通信同样会有一个额外的组件来包含输出数据,如果后续执行需要此数据的话组件就会被使用。8 ~$ B; U% J4 b* J4 O
0 a) V3 p- V7 a* k
就像合约创建一样,如果消息通信执行退出是因为gas不足或交易无效(例如栈溢出,无效跳转目的地或无效指令),那么已使用的gas是不会被退回给原始触发者的。相反,所有剩余的未使用gas也会被消耗掉,并且状态会被立刻重置为余额转移之前的那个点。7 L) P5 d  }3 c( j) k, R" j
4 g- z+ d. z  Z/ K3 A# y
没有任何方法停止或恢复交易的执行而不让系统消耗你提供的所有gas,直到最新的以太坊更新。例如,假设你编写了一个合约,当调用者没有授权来执行这些交易的时候抛出一个错误。在以太坊的前一个版本中,剩余的gas也会被消耗掉,并且没有任何gas退回给发送者。**但是拜占庭更新包括了一个新的“恢复”代码,允许合约停止执行并且恢复改变的状态而不消耗剩余的gas,此代码还拥有返回交易失败原因的能力。**如果一个交易是由于恢复而退出,那么未使用的gas就会被退回给发送者。
  ~1 M) B7 f2 j: M$ K1 e0 H4 b
. N, q  @3 ^7 n# i执行模式
8 q! ?/ N6 V. \5 ~1 q5 [* s3 }
! T- p% Z# W$ |( d+ E' Z; k7 U到目前为止,我们了解了从开始到结束交易的执行必须经历的一系列步骤。现在,我们来看看交易究竟是如何在虚拟机(VM)中执行的。: |1 A! N& a- k9 a" e2 y

; U0 J6 @  S4 X协议实际操作交易处理的部分是以太坊自己的虚拟机,称之为以太坊虚拟机(EVM)。' A9 e+ R8 k: E* Z9 W( _
- a- S. q9 B; c, i0 g
像之前定义的那样,EVM是图灵完备虚拟机器。EVM存在而典型图灵完备机器不存在的唯一限制就是EVM本质上是被gas束缚。因此,可以完成的计算总量本质上是被提供的gas总量限制3 e( Q2 S. f6 N; g8 ~

$ d. j, V( U; v此外,EVM具有基于堆栈的架构。堆栈机器 就是使用后进先出来保存临时值的计算机。, a! E3 ~5 G# H: R$ @2 @

! e) a+ `8 m/ v+ i4 j8 l5 XEVM中每个堆栈项的大小为256位,堆栈有一个最大的大小,为1024位。6 M$ W5 }- b( S. M$ s, D) Z

4 y# Z% O; p4 j4 O3 yEVM有内存,各项按照可寻址字节数组来存储。内存是易失性的,也就是数据是不持久的。
4 |& \( ^; R7 _* {' X+ j8 S( k1 e, U; b+ R8 E2 m, X
EVM也有一个存储器。不像内存,存储器是非易失性的,并作为系统状态的一部分进行维护。EVM分开保存程序代码,在虚拟ROM 中只能通过特殊指令来访问。这样的话,EVM就与典型的冯·诺依曼架构 不同,此架构将程序的代码存储在内存或存储器中。% ]. V* ^- N3 i; C/ q' B

% Y8 p# K- s+ r/ q; {& hEVM同样有属于它自己的语言:“EVM字节码”,当一个程序员比如你或我写一个在以太坊上运行的智能合约时,我们通常都是用高级语言例如Solidity来编写代码。然后我们可以将它编译成EVM可以理解的EVM字节码。6 P4 n" A6 {3 f. g! b# @+ W
) @8 T! Y" l# L: ]3 m
好了,现在来说执行。/ O0 @9 y. o' U

- w2 r: ?/ s" L在执行特定的计算之前,处理器会确定下面所说的信息是否有效和是否可获取:
: a9 J/ Q: `$ |: c+ }
1 Z- V4 i  h/ n6 s" k; v7 B系统状态
- T6 w: g: E$ ~: ]' J; t3 `. A6 d' d, ]
用于计算的剩余gas
, b) q8 A$ ?& e8 n  l- a+ v# V0 [0 `, w
拥有执行代码的账户地址
  Z1 G% c% o) q" q1 S- t1 l' W1 f: Z3 H: ]
原始触发此次执行的交易发送者的地址
- i, X5 K5 R6 V# ?7 o
7 U) o( M: Z1 u+ s1 s' |触发代码执行的账户地址(可能与原始发送者不同)5 X3 K4 c1 h. n! X4 r/ p

1 s; W2 {5 Y) |! B' h, j触发此次执行的交易gas price; U% E& ?+ q- `( Q5 j2 V

9 K) K+ k3 D* W此次执行的输入数据
6 G: |4 ^/ z3 a: ^% g  y5 Y9 A2 x: t) K3 B7 b9 ?; Z
Value(单位为Wei)作为当前执行的一部分传递给该账户0 K8 [, v& V& x/ v- p4 `* E; L

- e+ x; ^' t: W+ m0 v待执行的机器码- q# u8 G! U  P1 q2 m/ c6 A

/ \9 g9 l' P, z  s+ O当前区块的区块头( l  t- p" X$ s) @+ k
" F$ ]; m# s. s) v  k( ?$ r
当前消息通信或合约创建堆栈的深度: c, F. V1 u' b. e: |, n$ i
1 M! Y2 ~  f. u& E7 p- U' h! C# q
执行刚开始时,内存和堆栈都是空的,程序计数器为0。& a2 g5 j3 L$ q$ w4 [( i- n

( A8 ^1 G; u5 _( {; l: y执行刚开始时,内存和堆栈都是空的,程序计数器为0。" J( H$ L7 l" R3 k6 t2 D1 l: M% o
% u3 p. ~3 T- @8 N" Y: h- m3 s
PC: 0 STACK: [] MEM: [], STORAGE: {}9 `5 x+ w1 O0 K9 ^" e  w
& I1 {" f' S" [2 d# ~) U6 v6 A* ~
然后EVM开始递归的执行交易,为每个循环计算系统状态和机器状态。系统状态也就是以太坊的全局状态(global state)。机器状态包含:
& R% `1 ?( o$ q% o/ R' \
( D5 Z9 H. G$ i# r6 `可获取的gas
5 {; Q$ K  }9 z: y; Z8 T. g! y0 p% a: ~% S$ ?  W
程序计数器7 q* q$ M9 w" P) d7 ]2 [: |8 B
' [  g" P/ z0 k
内存的内容+ \* k. K. F) z; N2 W9 a7 a, @# I3 g
# m. U- A8 v$ y* E% b
内存中字的活跃数
6 _4 h% u. `+ w( g
6 D7 c* n# [$ b5 Z# |% ~堆栈的内容
5 X& E* S& `+ _8 D( ^2 g( ~4 j4 O- l
堆栈中的项从系列的最左边被删除或者添加。* N: r( B/ \" ~5 w
/ k9 f/ V5 b# B- P+ Y  z
每个循环,剩余的gas都会被减少相应的量,程序计数器也会增加。# {8 @4 ]6 c: i: C& F( m

- o9 D1 D6 U( ^1 {4 n1 P在每个循环的结束,都有三种可能性:# q9 T- e# }# {

4 M* W: f3 t4 f1 v. f0 ~* H) ~. @机器到达异常状态(例如 gas不足,无效指令,堆栈项不足,堆栈项会溢出1024,无效的JUMP/JUMPI目的地等等)因此停止,并丢弃所有更改) V0 n) ]) ^, g- |' o3 \

' e" E$ B% {; `/ `" M" D: w7 i  [进入后续处理下一个循环
7 _+ u1 e& f0 }# o+ f9 Y8 x( j% C# ~$ g* R2 v1 S) H) T% ^
假设执行没有遇到异常状态,达到一个“可控的”或正常的停止,机器就会产生一个合成状态,执行之后的剩余gas、产生的子状态、以及组合输出。: m4 M' h. e9 K% F4 a/ Y
$ k. P0 ~$ R9 B$ F- u9 ~! T
呼。我们终于过了一遍以太坊最难的部分了。如果你不能完全理解这个部分,也没关系。除非你在研究非常深层次的东西,否则你真的没有必要去理解交易执行的每个细节。
: V$ Z  C8 \( S9 D6 G1 Y8 E: e/ ]& y0 \/ c% _
一个块是如何完成的?- c4 {% I& q* H
# p+ O+ _  u$ x/ Z1 w) V
最后,让我们看看一个包含许多交易的块是如何完成的。
+ N2 d* n- {8 O5 m/ @8 `
4 y) u- |- v# g% n2 x4 l  A当我们说“完成”,取决于此块是新的还是已存在的,可以指两个不同的事情。如果是个新块,就是指挖这个块所需的处理。如果是已存在的块,就是指验证此块的处理。不论哪种情况,一个块的“完成”都有4个要求:
# B9 s0 n0 J: H9 W- n4 A5 x% n; G# O4 d4 t, L2 s
1)验证(或者,如果是挖矿的话,就是确定)ommers) ?  M6 O9 U6 M
- p6 i8 x9 ?6 V: S3 _
在区块头中的每个ommer都必须是有效的并且必须在当前块往上6代之内8 {* \) z( v( J2 w( ~, h
9 O, v& w1 ]3 o6 z1 i* @+ r
2)验证(或者,如果是挖矿的话,就是确定)交易
. m/ N0 B- S0 i+ c
/ O7 J% p4 A; E/ f# X& ?. Y% k区块中的gasUsed数量必须与区块中所列交易使用的累积gas量相等。(回忆一下,当执行一个交易的时候,我们会跟踪区块的gas计数器,也就跟踪了区块中所有交易使用的gas总数量)
- V  f% j& I' i
* H0 S# U0 V7 x3)申请奖励(只有挖矿时)
. B7 T& g( t- M  R1 }9 Y5 f
$ D" l# b- q4 i' Z2 r; }0 [6 j受益人的地址会因为挖矿而获得5Ether(在以太坊EIP-649 提案中,5ETH很快将会被减少为3ETH)。另外,对于每个ommer,当前块的受益人会获得额外的1/32当前块奖励金的奖励。最近,每个ommer区块的受益人能够得到一定量的奖励(有个特殊公式可以进行计算)。
) E. ^+ W$ }& y; @8 O: E# E; R: g5 a6 P' q. _1 c4 b
4)校验(或者,如果是挖矿的话,就是计算一个有效的)状态和nonce2 s  P9 T, T2 N% S. k" o1 b6 u3 W( y
' W% q, g) |+ }& S! i4 r
确保所有的交易和改变的结果状态都被应用了,然后在区块奖励被应用于最终交易结果状态之后定义一个新块为状态。通过检查最终状态与存储在头中的状态树来进行验证。
" D& ]: D: N3 R- u
4 u) y; v0 [- |工作量证明挖矿
: {6 y/ J4 R3 `# _
$ r# |1 Y5 L$ a5 p/ i! L3 W在“区块”这个章节简短的说明了一下区块难度这个概念。给予区块难度意义的算法叫做工作量证明(PoW)。
# [1 i" b* ~9 ]4 q- k1 _
. W) x" d6 C- J) S以太坊的工作量证明算法称之为“Ethash” (之前叫做Dagger-Hashimoto)。$ ~8 @  I4 ~: n$ U0 z
, F& k) B, ]4 w
算法正式定义为:% ?- i3 H" B% p% o+ o8 Q
4 E' a9 x- P2 Q& p1 |1 t8 B* ]
代表的是mixHash,n代表的是nonce,Hn代表的是新区块的头(不包含需要计算的nonce和mixHash),Hn是区块头的nonce,d是DAG ,就是一个大数据集。
0 ^+ x2 X) x3 n) |+ }: V
# v; M, T+ H2 U; Z# {9 }; ~9 i6 n! M, H在”区块”章节,我们讨论了存在于区块头中的多项。其中两项叫做mixHash和nonce。也许你会回忆起:
' r& D2 f1 j1 ^# H4 F4 R( _3 r2 R/ n( b
mixHash:一个Hash值,当与nonce组合时,证明此区块已经执行了足够的计算
# S, o- ?/ W. R4 R# C" ^0 B  m
9 M+ N0 e# c+ }) Y- Y( ]2 [nonce:一个Hash值,当与mixHash组合时,证明此区块已经执行了足够的计算
! M% X% w- S0 x6 r" X% ?, v) V+ Q9 H7 k3 @
PoW函数就是用来估算这两项的。
8 m9 m7 F. M; t8 b* _% K5 J3 P+ }! k( P9 k4 m4 N1 |
mixHash和nonce到底是如何使用PoW函数来计算出来的有点复杂,如果深入了解的话,我们可以另写一篇文章来讲解了。但是在一个高层面上,它大致就是这样计算的:/ D, H6 b! t: A+ A5 f
/ N2 J% U+ L/ f. M/ E% K; Q( C
会为每个区块计算一个”种子”。每个“时期”的种子都不一样,每个时期是30,000个区块长度。对于第一时期,种子就是32位0的Hash值。对于后续的每个时期,种子就是前一个种子Hash值的Hash值。使用这个种子,节点可以计算出一个伪随机“缓存”。2 H, R. w) y, g: t. u  {+ G/ Y

/ Q, y! x5 Z2 k! L! s这个缓存是非常有用的,因为它可以使“轻节点”的概念变成现实,轻节点概念在这篇文章的前面讨论过。轻节点的目的就是让某个节点有能力高效的校验交易而用不着存储整个区块链的数据集。一个轻节点可以仅基于缓存来校验一个交易的有效性,因为缓存可以重新生成需要校验的特定块。
8 o7 N7 O  T8 j8 a! w5 |
, n+ B) e; V. ?& Y7 Z4 `使用这个缓存,节点可以生成DAG“数据集”,数据集中的每项取决于缓存中少量伪随机选择项。为了成为矿工,你需要要生成全数据集,所有全客户端和矿工都保存这个数据集,并且这个数据集随着时间线性增长。1 `! F% f% }+ [/ o
8 ?% a2 |3 ^% K6 b" x
然后矿工可以随机抽取数据集中的部分并将它们放入一个数学函数中Hash出一个”mixHash”。矿工会重复生成mixHash直到输出的值小于想要的目标值nonce。当输出的值符合这个条件的时候,nonce就被认为是有效的,然后区块就被添加到链中。
" o- s4 _, y& ^- [9 K' s; @
5 x5 g1 Y8 T# _1 m/ Z4 ]. z挖矿作为安全机制
6 z! D- i* J1 E; L( T1 N* `- h
) x8 `' l% ^( B总的来说,PoW的目的就是以加密安全的方式证明生成的一些输出(也就是nonce)是经过了一定量的计算的。因为除了列举所有的可能性,没有更好的其他方法来找到一个低于要求阈值的nonce。重复应用Hash函数的输出均匀分布,所以我们可以确保,在平均值上,找到满足要求的nonce所需时间取决于难度阈值。难度系数越大,所需时间越长。这样的话,PoW算法就给予难度这个概念意义了:用来加强区块链的安全。; N2 V# C# q  I# O
# o0 |9 q; S4 s, A/ u
我们所说的区块链的安全又是什么意思?这非常简单:我们想要创造一个每个人都信任的区块链。像我们之前在这篇文章中讨论的那样,如果存在超过1条以上的链,用户的信任就会消失,因为他们没有能力合理的确认哪条链才是“有效的”。为了让一群用户接受存储在区块链中的潜在状态,我们需要有一群人信任的一个权威区块链。
& k: _: \! d6 n' r! h2 p
4 i5 `$ h3 i) l! N; n) W这完完全全就是Pow算法所做的事情:它确保特定的区块链直到未来都一直保持着权威性,让攻击者创造一个新区块来重写某个历史部分(例如清除一个交易或者创建一个假的交易)或者保持一个分叉变得非常困难。为了首先让他们的区块被验证,攻击者需要总是比网络上的其他人更快的解决掉nonce问题,这样网络就会相信他们的链是最重的链(基于我们之前提到的GHOST协议原则)。除非攻击者拥有超过一半的网络挖矿能力(这种场景也被称为大多数51%攻击 ),要不然这基本上是不可能的。
+ N& I1 N( x  u, b
4 a! l! o0 x) y. p6 |$ W) |; j6 {挖矿作为财富分配机制' Y( f1 m+ `+ {% E, e) H

+ M3 u( r0 p. v  G/ o% f3 R除了提供一个安全的区块链,PoW同样也是分配财富给那些为提供这个安全而花费自己计算力的人的一种方法。回忆一下,一个矿工挖出一个区块的时候会获得奖励,包括:
1 K6 {: t& r1 |: i4 r
( [2 e! G4 x% Y0 [/ r' r$ x0 k为“获胜”区块提供的5 ether静态区块奖励(马上就会变成3 ether )" {; ?& j# a+ _: u& `

/ O/ J% S& A# l6 D  m; \, M区块中的交易在区块内所消耗的gas
6 k9 D( l) Z5 f: a% V/ ?! S; }9 N. p$ T
纳入ommers作为区块的一部分的额外奖励
/ N% I4 ^1 b+ z. w8 i% {
; S! h5 [9 f9 |0 m. `2 f3 m  R6 L为了保证PoW共识算法机制对安全和财富分配的使用是长期可持续的,以太坊努力灌输这两个特性:
4 G, M, b/ ~; G4 e% s0 h1 W; _0 ?1 |* I' O, j' D! z+ q/ h
尽可能的让更多的人可访问。换句话说,人们不需要特殊的或者与众不同的硬件来运行这个算法。这样做的目的是为了让财富分配模式变的尽可能的开放,以便任何人都可以提供一些算力而获得Ether作为回报。0 [# Y" C3 ?$ g& h/ Z

% d- S( _6 \0 H# b1 x降低任何单个节点(或小组)能够创造与其不成比例的利润可能性。任何可以创造不成比例的利润的节点拥有比较大的影响力来决定权威区块链。这是件麻烦的事情,因为这降低了网络的安全性。
% m' k2 C, ^2 Q& Y3 t4 g  e8 z3 g* s3 S0 x: q
在区块链网络中,与上面两个特性有关的一个问题是PoW算法是SHA256哈希函数。这种函数的缺点就是它使用特殊的硬件(也被称之为ASCIs)可以更加快速高效的解决nonce问题。6 Y+ y: a) ]9 K
- G0 R1 i! b0 E  o
为了减轻这个问题,以太坊选择让PoW算法(Ethhash) 提高内存级别难度。意思是此算法被设计为计算出要求的nonce需要大量的内存和带宽。大量内存的需求让电脑平行的使用内存同时计算多个nonce变得极其困难,高带宽的需求让即使是超级电脑同时计算多个nonce也变得十分艰难。这种方式降低了中心化的风险,并为正在进行验证的节点提供了更加公平的竞争环境。
* f" ]( Y0 Z' }! g& Q& {1 h# V; p$ @: {% Y8 |3 b0 c# R
总结4 Q- d$ O( w2 `" ?
& a, u7 S( \% z6 N. C$ b+ a9 s1 Q$ A
呼! 你终于坚持到最后了。我希望如此?5 [0 `# U, y( O/ R, U: c3 A
' N4 J  Y/ _" Q2 }
这篇文章中有很多的地方需要消化。如果需要你阅读好几遍才能理解怎么回事,这完全正常。我个人重复阅读了好几次以太坊黄皮书,白皮书,以及代码的不同部分才渐渐明白是怎么回事。# B$ U1 ~4 Y" {& v
9 y$ b/ o7 l7 l! P+ o+ e
无论如何,我希望你觉得这篇文章对你有帮助。如果你发现了任何的错误或失误,我很乐意你给我写个私人消息或者直接在评论区评论(我保证我会查看所有评论)。
5 k: L- P+ B0 i% o- H* U% `- n$ v9 K2 ~7 }3 O
记住,我是个人类(对,这是真的),我会犯错误。为了社区的利益,我花时间免费写了这篇文章。所以请你在反馈时不要带着没必要的攻击性,尽量是建设性的反馈。
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

stanstan 小学生
  • 粉丝

    0

  • 关注

    0

  • 主题

    1