Hi 游客

更多精彩,请登录!

比特池塘 区块链前沿 正文
    一个用于维护不断增长的记录列表的分布式数据库,我们称之为区块链。- L3 T$ \8 _& R: v( s6 X

) |9 @( l5 j+ E    这听起来很棒,那它是如何工作的呢?
" A& b4 [6 V$ a; M. ~! v" Q, a6 G" k2 z/ F
    为了说明区块链,我们将会使用一个名为BlockchainCLI的开源命令行工具。
3 P) y0 J/ x# I+ Q: H* f0 U! T. ~" y7 H5 ], \- G7 D+ a
    我同时也建立了一个基于浏览器的版本6 m( a6 ~' x( M9 N# ]  I

! l' _0 M$ l+ N' D    安装命令行工具
, ]: O# k, |3 F; F, Y- L0 I7 u" `
4 r, o  P% g$ G( r. d    在此之前请先安装Node.js2 s$ g5 |: R5 ^0 x/ s
6 v! @5 P! a6 q3 g1 ]
    然后在你的命令行中运行以下指令:' r6 h' L4 J7 s, S% d
" W* e" `0 y0 g  j& {$ t8 u2 t: A
    npminstallblockchain-cli-g
% Y+ |+ t0 ]9 P9 G& f! @# i  I+ j
  d! o" W: F, m1 K. n* p    blockchain9 u: w$ b# f4 M# j

3 n' w" x+ o0 ~0 J9 b    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
8 F& @0 B( q; w; N* a2 y
4 b9 Z" o4 h( D# M$ e9 p, u    区块长什么样?
# D$ l$ z( o. T6 E3 \
! @. i/ w/ Y1 b' H" |; j7 Y6 M    想要查看当前的区块链,你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。( R# _/ ?$ f3 ?% ^# F8 H

2 K* K# i( `; n% o" k1 Y4 E" h    Index:是哪一个区块(创世块的索引是0)& H( h/ k/ n: O" Q5 z; h  H$ i; u

) K/ s$ a6 F9 m4 D( z% G    Hash:块是否有效?" Q8 J' H: q) N6 @, y
2 a, s' Z3 y8 G: _
    PreviousHash:前一个区块是否有效?( ^  e0 x. k0 {* L& c: @; r
5 V2 l' ?* @2 P+ l9 @) G
    Timestamp:什么时候添加的区块?* K6 M# J3 S; m$ D- r- {6 ~

, ^4 [* f4 `& c) y9 G% I    Data:什么信息存储在区块上?0 K' ]2 g( s$ W

6 v: p* `2 ~7 D. p" I    Nonce:在找到有效区块之前,我们进行了多少次迭代?
( U2 C" A* Y6 B# ]  r+ `' P( L( n& ~0 g5 w/ j0 e
    创世块
# q( X- \2 ~6 W0 }) T6 Y
! I" H# l7 T( Z# |    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的,区块链上的每一个区块都依赖于前一个区块。所以,需要创世块来挖出我们的第一个区块。
% U- c% f1 c% o# F1 k; u" N% m4 J' ^. j! l6 H& b3 S6 i/ X! f# n# v: }
    当一个新的区块被开采时会发生什么?
# A$ _% V$ X. f; z! h9 b7 k9 B) K4 y
    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。+ ?# L( k/ J$ b; y1 |: N7 V1 P- {
! B  t, c# E6 }: j
    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。! y7 g& c# |$ A

2 M! p- w+ s5 a5 a0 q* T* a9 U8 [6 k    Index:0+1=1
" p5 a7 D$ I1 Z1 ]6 l  k# l
$ L+ m( p9 J3 r4 k5 ~+ t( Q" t    PreviousHash:0000018035a828da0…) A! w0 s% L( H1 \- }. X7 ^

% Z* I4 m0 z$ Q+ C    Timestamp:区块被添加的时间
, E7 l& r2 d3 c# K, v
$ P( J$ ?! c8 M3 l/ i! |( w" Q    Data:freeCodeCamp5 s- t! j. @9 x0 B& o$ C4 i
5 n9 T% ~5 H+ C
    Hash:???
7 u% J8 U) @" _" N! b0 Y9 N8 S1 h( o( n$ ^% F( T
    Nonce:???
- W( _. a# }! q) g
  d. m' t2 O/ Z, M" l" }    Hash是如何计算的?0 d' @# M& u4 ]1 S( E, u1 H$ H
6 x1 N4 @; r& y
    哈希值是唯一标识数据的固定长度的数值。5 M/ a& l1 C2 Z/ s7 F% w- |7 Y! e) o
; K2 n9 x6 L# _* S
    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。  E3 h5 U( W2 n' ]( b$ U* B# O
3 O) Q+ Z6 r- Y) x
    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)- |6 i  T9 Q% {- ^! p1 [% B
9 ]' h, T! g6 q& s7 M
    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。* ?8 l" ~" y$ n; Z5 Y( i  X+ S8 q
! v* y. s8 ^$ b0 X7 K
    你是否注意到区块Hash中的四个前导0?2 ?4 n2 y$ O, a  {# X2 U* L
9 @; T0 a+ k: d  y( x; k% |1 Z
    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度
6 x9 r( z$ a$ d1 Y2 f) f
: _5 y' f; _( r1 A+ f. g    functionisValidHashDifficulty(hash,difficulty){: T% a9 D4 M/ v6 @7 ~! X) s9 v

1 n  }1 w, n9 A# w7 E: n. H    for(vari=0,b=hash.length;i=difficulty;( N. b1 E6 ?- q

' A" d/ M" R. b: r5 S% R+ D7 b1 s5 ~% W! o    }
- u1 Q7 P- Q# S+ v( @" G5 j
- `% f  F$ b. Z/ w, c. N    这也被称为工作证明系统3 I. `9 r1 }, q7 m# ~" l
1 i8 n0 X: p1 i' I5 M- u
    Nonce是什么?
' x8 a. `' a- t2 i" }$ A- U& |
    Nonce是用来查找一个有效Hash的次数。
, s" N( v: F; Q& _# Y* T
. _0 \6 A$ e) N& n6 N    letnonce=0;# r9 a) h. d8 {  r

3 J3 f6 V8 U! P% y( E0 ]! l    lethash;
7 ^- V& |! M% f" _* S/ E* i0 B$ O% f
    letinput;7 \1 c, }$ V$ v
8 s% P# Z. ?$ y  r+ O3 J
    while(!isValidHashDifficulty(hash)){/ V7 M3 C9 `5 g8 y1 w. o
% u4 C/ i' t0 q6 V
    nonce=nonce+1;
! j+ Z! H5 X, X6 R9 }
7 n! @% v' _8 Z2 {) R    input=index+previousHash+timestamp+data+nonce;. \8 c6 V  S, c
& S. S% |9 o3 L& v; \- e8 C
    hash=CryptoJS.SHA256(input)
+ o1 z6 g! L- p" {1 F1 ]; P
2 Y' U# r9 o& t% p& h, O* U! J    }5 L3 s! [, A+ t) H4 V: o
4 O3 w! l. W/ S4 K4 F
    Nonce迭代到直到Hash有效。在我们的案例中,一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。! }7 e; s  H% _. s7 W) `

9 {& ~1 z, n* ]: s    随着难度的增加,可能的有效Hash数量就会减少。伴随着有效Hash的减少,我们需要更强的算力来查找有效Hash。
! a  i& p  v. ~3 J* l2 y; ^3 j" m' j8 e- c# y+ ~
    为什么这么重要?, m5 X& q7 N0 z. [$ I( @5 Y$ s

+ m8 s& O$ L' t, b0 c* T: \    这些机制非常重要,它们使区块链不可变。. d' t. {' e# ^. Z( o, R

' l  k4 o5 e4 w( i    如果我们有这么一个区块链“A->B->C”,而且有一个人想要改变区块A上的数据。那么会发生什么呢?
, L  a! i8 r& u" n- `8 i% B; m, A- \9 x1 A5 S6 U3 y: d
    区块A上的数据改变了。
% R3 x- |# ?7 L2 J) Y1 F
) q( l% H1 Y. I6 n  l    区块A的hash改变了,因为数据被用来计算hash。
" P7 v8 g- I, C2 a. J* Y' f+ s  x- e% E6 b/ P
    区块A失效了,因为它的hash不再有4个前导0。
% O' ^! a# }! \* z; p) q! I; T: {: s- E; X* |  o6 Q# z
    区块B的hash改变了,因为区块A的hash被用来计算区块B的hash。
$ w( M& ^& j. J# Q' r$ ]# d5 c& Q! Q7 g3 n" c
    区块B失效了,因为它的hash不再有4个前导0。
6 h; S; J2 S8 H7 k, Q; R, X$ g. F8 K8 _) E; X, c- \
    区块B的hash改变了,因为区块C的hash被用来计算区块B的hash。
; d  g3 a# S6 G9 \5 M. ?* K0 Q3 d8 I  c+ {% x# {$ X8 e( X
    区块C失效了,因为它的hash不再有4个前导0。8 l& {- n1 l/ i

* F* x) F7 [' H3 r# J! c    改变一个区块的唯一方法就是将这个区块重新挖一遍,接下来是所有的区块。由于总是有新的区块被添加,因此改变区块几乎是一件不可能的事。
: J' [! c8 F/ ?2 I. L  Z' [
1 Z7 y7 R! [' v' y8 X    我希望这个教程能够对您有所帮助!' G" m- d" @9 S) a& i2 ?
) |( w) g! G$ R  y
    安装命令行工具
0 P  J5 {' |3 W. n. G# k- e- V
    在此之前请先安装Node.js; ]" H: [+ D4 r$ q

/ E7 h2 p" d: J( y  {6 u* {( b* a! c8 _    然后在你的命令行中运行以下指令:
3 T0 x* b3 |) A4 I$ k% W; S$ F3 e
! J$ p+ @2 X$ A- q# J) v    npminstallblockchain-cli-g3 q# q( p# m* ]3 _; ?5 G
% w! r9 C, J$ a* j5 ~
    blockchain
% M4 L. t! |8 x2 P% [
/ _  I9 X. f  O9 N! C$ h3 N    你应该会看到?WelcometoBlockchainCLI!和一个blockchain→提示。这说明已经准备好了。
3 y- v$ D6 W) v1 D& J0 J8 N/ H: E+ U, `* y% P# L
    区块长什么样?
, i" l* L0 d( F, L
/ |7 B- p" [. }6 ~5 n' t    想要查看当前的区块链,你需要在命令提示行下输入blockchain或者bc。你应该会看到像下面的图片一样的一个区块。/ W3 `, `1 R- k# _' e  W

! h" F  h+ [  t: g" I) \; S    Index:是哪一个区块(创世块的索引是0)?
+ y& p$ \  Y/ Q2 L) K* z/ d2 ?8 A- f9 g! \& K9 x
    Hash:块是否有效?
: q5 r/ t1 }! b: l8 H9 |& r- c* R1 o
7 x! K" t* T  u! l$ s. `    PreviousHash:前一个区块是否有效?( O1 X$ A4 M3 T* [/ y
" z" U& M, N& o. A) R
    Timestamp:什么时候添加的区块?
1 o/ }2 Z2 K, h% V% r) o% p* g  {! b5 Z+ i2 N% X
    Data:什么信息存储在区块上?) c, O( A9 Q6 f$ b' w" [5 B
$ a( U. n! ?7 \7 k6 z+ y6 l
    Nonce:在找到有效区块之前,我们进行了多少次迭代?- h3 B0 I3 E, V; J* `
% L  x; P, R9 @
    创世块8 [% Y$ A. F% V0 K- @6 Q' I8 F/ R

. Y: X) L9 {1 z$ d/ H: m2 r  g    每一个区块链都是从?GenesisBlock开始的。正如你们将要在后面看到的,区块链上的每一个区块都依赖于前一个区块。所以,需要创世块来挖出我们的第一个区块。
* F1 W- E, P7 W6 C1 o3 h; g& O$ _5 P1 q
    当一个新的区块被开采时会发生什么?
  u+ n( k# ^: X  ]& A+ Q7 I% u
- y9 Y& S8 {3 f# B+ \" o* w* Q    让我们挖出我们的第一个区块。在命令行中输入minefreeCodeCamp。9 X- H3 |3 X' p1 j& Q* x

. ^8 r& \9 h. f1 E! i# v0 Y" Y! _8 h: Y$ r    区块链查看链上最新的区块来获取index和previoushash。在这个案例下创世块是最新的区块。
5 L$ X" U, E! C$ B- H
7 T, M' `! ^1 x( z  J; c4 M    Index:0+1=1# h9 D$ t/ r9 S8 M0 w

' v# h4 l; H) l6 G. ^    PreviousHash:0000018035a828da0…) M5 k% F/ b$ Y
% F/ ~! L0 C0 D! t9 j: f9 d
    Timestamp:区块被添加的时间
" P3 u9 u7 V# k+ h* H
( \3 ?4 C2 t# z" e8 s+ z/ ~2 V6 ^    Data:freeCodeCamp
! T8 l! M6 q) X- j; x" s$ I& X  E/ i* s* J4 r  k6 ]
    Hash:???% e- u% Y1 w( x$ ^7 T, X1 V9 g
9 Y! `( H; S& P1 z- p2 t
    Nonce:???
) G' e  z5 ^. M! o9 h: o- H: z1 N5 ?4 S7 U" u% c( V
    Hash是如何计算的?
" @5 ^& }- t- o1 H2 n0 T! r0 t. \1 v5 C1 C: h& U, L, Z
    哈希值是唯一标识数据的固定长度的数值。$ V4 C0 P9 q0 X' n2 s0 ~$ ]: _/ q

3 d0 v0 E* a. I, F9 F2 O    Hash是通过将Index、PreviousHash、Timestamp、Data和Nonce作为输入值来计算的。# r9 T) V9 }9 v3 J# l

- b( `3 U  Q0 ?% }    CryptoJS.SHA256(index+previousHash+timestamp+data+nonce)
  }5 o! y7 @. A9 e3 g" d# T
# c8 J5 W' ?* V    SHA256算法将会依据这些输入计算出一个唯一Hash值。同样的输入总是会返回同样的结果。
! x: y( |8 S. b% q3 k  a
6 P* `: U" L$ X& O3 x4 s    你是否注意到区块Hash中的四个前导0?9 F$ z! {9 g3 _. U- x0 V

) J" p: C: W1 \! A3 u% M( o    四个前导0是一个有效Hash的最低要求。所需前导0的数量被称之为难度4 `1 J! `& a8 x* [) U9 G3 {6 M
3 D5 J4 \2 c2 J8 o% d2 A& ^8 ?
    functionisValidHashDifficulty(hash,difficulty){
+ k, O: t, |8 X5 Q3 x+ m; }8 q* j8 H# g* a9 K: [
    for(vari=0,b=hash.length;i=difficulty;
7 g& f; B% f- z+ b) t. I  P' [
- {, n5 i+ p0 s+ k    }
  \5 N# S. p) R! H% r! p" R
/ X, w, N, v& L2 ^2 U. o    这也被称为工作证明系统% i1 x3 W( a& ^8 X: ~2 L9 Y

- d1 C7 S# t! H$ ~" l4 Y) N    Nonce是什么?
( b/ u% B' G+ U' g. g0 T. e! J9 Q, G' u, M; u8 \
    Nonce是用来查找一个有效Hash的次数。
0 V2 J. N! D  D% h9 d
9 t6 a1 R1 @% O) S    letnonce=0;. ]8 ^# L& f% d. t2 a6 [

9 ?4 P) H6 e; v5 W# _1 Z    lethash;1 |9 R, n! H7 O0 l# G

  ^6 c0 S- ^" l8 x/ X1 c    letinput;
! x1 Q. a8 a. P1 L( V" S: t" |; W- i1 ]9 c# Z
    while(!isValidHashDifficulty(hash)){
3 G% @3 S: t  b4 X3 z8 R; u( b
7 A# a9 o% z+ N2 P    nonce=nonce+1;, O* W  z( T/ W8 W& m5 C6 x
. T9 z3 {3 N* k( K* L
    input=index+previousHash+timestamp+data+nonce;! t$ X! w( e9 k% R
1 D* E* y9 _2 t3 I
    hash=CryptoJS.SHA256(input)8 c, t) S' P* S0 I! K

0 L3 w) M" g0 M6 F% t  G    }  @3 @& Q- E+ b% M) F

) g, T# ]) ?2 Y# @1 I  U7 x9 X    Nonce迭代到直到Hash有效。在我们的案例中,一个有效的Hash至少要拥有4个前置0。查找与有效Hash对应的Nonce的过程就是挖矿。
9 u, @. }" A; e- b; {3 {! J4 F7 n% B( a  F
    随着难度的增加,可能的有效Hash数量就会减少。伴随着有效Hash的减少,我们需要更强的算力来查找有效Hash。
: B  L8 J( m3 C" J2 A$ M3 ^; g1 b$ j8 L& J; ?
    为什么这么重要?/ V' X0 s$ n9 L9 t: G
' n/ i& d& Q0 a
    这些机制非常重要,它们使区块链不可变。
: B$ @6 r$ r) w  F7 r" N& ?/ _2 d0 d& t+ S! X$ G% G1 ~
    如果我们有这么一个区块链“A->B->C”,而且有一个人想要改变区块A上的数据。那么会发生什么呢?
% H  E. v  N8 Q; u: S
( g4 H! S& \8 V- s5 ?& u    区块A上的数据改变了。
, a2 z' ]  I5 t$ T1 G  _0 o% N5 z2 I0 _
    区块A的hash改变了,因为数据被用来计算hash。
, v: s0 A/ O- b! a% ?0 y: w, ~
    区块A失效了,因为它的hash不再有4个前导0。
  R/ D3 [$ c, n5 c% O( M9 X0 K6 F7 D! i' P( J+ C
    区块B的hash改变了,因为区块A的hash被用来计算区块B的hash。
: g$ u* V/ m' Z; p+ ~9 `8 J; g5 o2 y8 P* x6 W/ N: ^
    区块B失效了,因为它的hash不再有4个前导0。: o* l, b0 E* d4 d2 Q
' K! F- x% ]5 m7 o. a
    区块B的hash改变了,因为区块C的hash被用来计算区块B的hash。2 u& {/ ^) g8 [2 L0 m8 o

, g, b: i5 S+ D' @( l    区块C失效了,因为它的hash不再有4个前导0。
1 p; V' ~; o4 L: W5 w2 s+ d1 K5 Z( i: F; n6 }# `8 Z
    改变一个区块的唯一方法就是将这个区块重新挖一遍,接下来是所有的区块。由于总是有新的区块被添加,因此改变区块几乎是一件不可能的事。0 I4 g. z' f) s+ _/ Q
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

段琰baby 小学生
  • 粉丝

    0

  • 关注

    0

  • 主题

    6