Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

用JavaScript写区块链代码

Kierra34656
80 0 0
几乎每个人都听说过像比特币和以太币这样的加密货币,但是只有极少数人懂得隐藏在它们背后的技术。在这篇博客中,我将会用JavaScript来创建一个简单的区块链来演示它们的内部究竟是如何工作的。我将会称之为SavjeeCoin!0 ?% ^/ \9 P# f. a$ h
全文分为三个部分:
, ]1 s' o- o0 V) `- h1 ipart1:实现一个基本的区块链3 ~! B, i: g' V% L
part2:实现POW. G; B5 k: Z! O" Y9 A3 I
part3:交易与挖矿奖励
5 \9 U/ D) V) q4 xPart1:实现一个基本的区块链
9 K- p, }4 w1 v5 d% @区块链
& M8 k) `  ]4 l2 W" z) S区块链是由一个个任何人都可以访问的区块构成的公共数据库。这好像没什么特别的,不过它们有一个有趣的属性:它们是不可变的。一旦一个区块被添加到区块链中,除非让剩余的其余区块失效,否则它是不会再被改变的。. @) a7 L( n% L8 i2 J
这就是为什么加密货币是基于区块链的原因。你肯定不希望人们在交易完成后再变更交易!& [. Q7 _. y( i4 \
创造一个区块
8 e5 ]/ y3 Q: K区块链是由许许多多的区块链接在一起的(这听上去好像没毛病…)。链上的区块通过某种方式允许我们检测到是否有人操纵了之前的任何区块。
5 [$ `: W' ?# N. R5 q! H那么我们如何确保数据的完整性呢?每个区块都包含一个基于其内容计算出来的hash。同时也包含了前一个区块的hash。
1 b, X* W7 m) U, S% m下面是一个区块类用JavaScript写出来大致的样子:# g. {, J, W- c" R
const SHA256 = require("crypto-js/sha256");
4 w4 o# X* x6 R2 Tclass Block {
% y# I. n: r. e5 I  constructor(index, timestamp, data, previousHash = '') {
, B: Y& r0 P1 B3 t% X3 o+ t% x    this.index = index;
* N) ~9 `7 u& u8 F/ {, h( _    this.previousHash = previousHash;
: `7 p5 Z6 c! M5 w1 Z6 j6 z5 ?    this.timestamp = timestamp;8 s: \) Z  P) y4 M; V  s
    this.data = data;
4 o& ?: I3 g2 w7 I4 R1 M    this.hash = this.calculateHash();
# F1 o! P5 f7 T5 W3 x+ p% x' t  }5 O" U$ L0 }" x+ j9 O2 B
  calculateHash() {
0 |4 _6 I& z, G) U: p! }    return SHA256(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data)).toString();* _1 |' D+ c9 O) H9 Q( L
  }
: \* n" @+ A4 A}
' C- M) u2 I, r* M" y6 b  `因为JavaScript中并不支持sha256所以我引入了crypto-js库。然后我定义了一个构造函数来初始化我区块的属性。每一个区块上都被赋予了index属性来告知我们这个区块在整个链上的位置。我们同时也生成了一个时间戳,以及需要在区块里存储的一些数据。最后是前一个区块的hash。+ \, Y/ H0 I$ p% T; |) R. o
创造一个链
" ^7 V4 R- T6 _( `$ U% h- f! ~现在我们可以在Blockchain类中将区块链接起来了!下面是用JavaScript实现的代码:6 w( |3 ]. G( n! A
class Blockchain{% y6 }2 n7 y' }2 N5 F
  constructor() {; q: V' D6 H1 B+ N
    this.chain = [this.createGenesisBlock()];, r1 ^$ f8 M( w. E# A
  }
  ]& I. v9 [5 q' [! O6 E" X) p  createGenesisBlock() {
7 e! v3 w  X" a3 Y    return new Block(0, "01/01/2017", "Genesis block", "0");5 c5 J* B( b; t& Z7 Q$ V
  }" [7 _- X3 A8 p# l& |6 n! h- W0 z
  getLatestBlock() {
5 [! |1 T' T0 r/ U' q0 g. w    return this.chain[this.chain.length - 1];# ?- z& ^& }* b7 ], b
  }
+ p: I5 h8 A1 ?# S2 C0 a  addBlock(newBlock) {" U" R; ~/ ~8 n& }
    newBlock.previousHash = this.getLatestBlock().hash;7 L# @9 Y$ ^% N& _4 Z
    newBlock.hash = newBlock.calculateHash();
4 r6 L6 m; ~+ r' Z7 T# Z    this.chain.push(newBlock);6 ?: ^1 G2 q5 `* I/ T  P
  }) ^9 r& A2 s8 v$ k) H2 O
  isChainValid() {
, Y8 Y" m8 S! Z) C7 @    for (let i = 1; i # z; f5 ?' a% k& g9 R( a5 n
在构造函数里,我通过创建一个包含创世块的数组来初始化整个链。第一个区块是特殊的,因为它不能指向前一个区块。我还添加了下面两个方法:
5 R2 R' b* Q0 B: w9 u$ I0 ~8 kgetLatestBlock()返回我们区块链上最新的区块。' H# w, d8 u& o/ d& r1 o- s- Z* \
addBlock()负责将新的区块添加到我们的链上。为此,我们将前一个区块的hash添加到我们新的区块中。这样我们就可以保持整个链的完整性。因为只要我们变更了最新区块的内容,我们就需要重新计算它的hash。当计算完成后,我将把这个区块推进链里(一个数组)。
  }8 _" Q3 W. U7 P( k( V最后,我创建一个isChainValid()来确保没有人篡改过区块链。它会遍历所有的区块来检查每个区块的hash是否正确。它会通过比较previousHash来检查每个区块是否指向正确的上一个区块。如果一切都没有问题它会返回true否则会返回false。
" D4 h+ q8 p! U* [6 N9 A4 z5 F使用区块链  `. [# f* l$ w. e0 h4 `8 x" w
我们的区块链类已经写完啦,可以真正的开始使用它了!
4 ]  U0 C; I4 L! R4 ]+ _8 Tlet savjeeCoin = new Blockchain();8 N, v) K# t4 L! [% D
savjeeCoin.addBlock(new Block(1, "20/07/2017", { amount: 4 }));
/ V. A) L" W# jsavjeeCoin.addBlock(new Block(2, "20/07/2017", { amount: 8 }));
; Z; i$ }( [/ j4 p在这里我仅仅是创建了一个区块链的实例,并且命名它为SavjeeCoin!之后我在链上添加了一些区块。区块里可以包含任何你想要放的数据,不过在上面的代码里,我选择添加了一个带有amount属性的对象。
* d  p5 x) g$ e( b8 ^2 F7 x) S试着操作吧!9 q4 r  K0 M+ o9 _' c3 n
在介绍里我曾说过区块链是不可变的。一旦添加,区块就不可能再变更了。让我们试一下!) T( U! g2 U/ j/ \' I" N  e& W& }
// 检查是否有效(将会返回true)
9 y4 V( C9 f  @* \$ M/ A/ a; uconsole.log('Blockchain valid? ' + savjeeCoin.isChainValid());
( K: W, Y; _7 w% A$ w# X1 E! N// 现在尝试操作变更数据5 F8 _) r7 h: v: q2 F. D# d/ `( ^
savjeeCoin.chain[1].data = { amount: 100 };
" p5 o( q- i3 ^7 A) e// 再次检查是否有效 (将会返回false)
7 @% o. F8 P+ g+ D6 r7 ^. P; fconsole.log("Blockchain valid? " + savjeeCoin.isChainValid());0 [% G+ h4 P- A) q1 D# i9 ?! N
我会在一开始通过运行isChainValid()来验证整个链的完整性。我们操作过任何区块,所以它会返回true。
$ s- u8 {2 N5 L: v5 z. f4 w之后我将链上的第一个(索引为1)区块的数据进行了变更。之后我再次检查整个链的完整性,发现它返回了false。我们的整个链不再有效了。( k' \5 G8 V" [/ u: s% v
结论
$ S% j, A8 j, b  T+ O2 m8 F这个小栗子还远未达到完成的程度。它还没有实现POW(工作量证明机制)或P2P网络来与其它矿工来进行交流。6 q; J2 r7 w3 D; T2 t1 }
但他确实证明了区块链的工作原理。许多人认为原理会非常复杂,但这篇文章证明了区块链的基本概念是非常容易理解和实现的。
; y: {' a! d% x1 m8 i- }6 U9 IPart2:实现POW(proof-of-work:工作量证明)/ E  [' J1 e8 ~; ?- ?% J
在part1中我们用JavaScript创建了一个简单的区块链来演示区块链的工作原理。不过这个实现并不完整,很多人发现依旧可以篡改该系统。没错!我们的区块链需要另一种机制来抵御攻击。那么让我们来看看我们该如何做到这一点!' f6 Z1 V. O$ W; _6 r
问题
; X, W& {& T1 ~现在我们可以很快的创造区块然后非常迅速的将它们添加进我们的区块链中。不过这导致了三个问题:) q' L0 ]5 B0 k* ?' f! u
第一:人们可以快速创建区块然后在我们的链里塞满垃圾。大量的区块会导致我们区块链过载并让其无法使用。第二:因为创建一个有效的区块太容易了,人们可以篡改链中的某一个区块,然后重新计算所有区块的hash。即使它们已经篡改了区块,他们仍然可以以有效的区块来作为结束。第三:你可以通过结合上述两个破绽来有效控制区块链。区块链由p2p网络驱动,其中节点会将区块添加到可用的最长链中。所以你可以篡改区块,然后计算所有其他的区块,最后添加多任意你想要添加的区块。你最后会得到一个最长的链,所有的其它节点都会接受它然后往上添加自己的区块。! S& G2 ^" J' @1 `! X
7 `- v/ l$ S. ~$ }# Y# w+ s1 L
显然我们需要一个方案来解决这些问题:POW。
, m4 E7 s2 T! j9 b1 W( g# D什么是POW
2 G; w8 ^; y9 M6 u; M1 JPOW是在第一个区块链被创造之前就已经存在的一种机制。这是一项简单的技术,通过一定数量的计算来防止滥用。工作量是防止垃圾填充和篡改的关键。如果它需要大量的算力,那么填充垃圾就不再值得。
% c9 S5 D: i8 e比特币通过要求hash以特定0的数目来实现POW。这也被称之为难度
) [3 c1 G9 p* R8 y% ^1 |! K" S不过等一下!一个区块的hash怎么可以改变呢?在比特币的场景下,一个区块包含有各种金融交易信息。我们肯定不希望为了获取正确的hash而混淆了那些数据。3 ?$ m" ^8 _3 j8 V: h+ U0 ]
为了解决这个问题,区块链添加了一个nonce值。Nonce是用来查找一个有效Hash的次数。而且,因为无法预测hash函数的输出,因此在获得满足难度条件的hash之前,只能大量组合尝试。寻找到一个有效的hash(创建一个新的区块)在圈内称之为挖矿。- j9 w# S( G0 J8 M% ?# \. m
在比特币的场景下,POW确保每10分钟只能添加一个区块。你可以想象垃圾填充者需要多大的算力来创造一个新区块,他们很难欺骗网络,更不要说篡改整个链。
- p: A- R- F# ^0 o实现POW" o6 p9 m: j! X3 b* M) M
我们该如何实现呢?我们先来修改我们区块类并在其构造函数中添加Nonce变量。我会初始化它并将其值设置为0。
4 H! {: q4 \9 Zconstructor(index, timestamp, data, previousHash = '') {! L* d* D' l4 y4 @9 i. U
  this.index = index;
- u- k8 q" g) S! g. j  this.previousHash = previousHash;7 G& m1 [+ x7 |9 a( F& w
  this.timestamp = timestamp;
( ]( o0 ?* P- O( \  this.data = data;* j5 _; E2 l' z$ U4 x
  this.hash = this.calculateHash();
' m5 X$ G8 v6 i7 R  this.nonce = 0;
+ k+ L* Z/ e% Q, g+ n3 z3 }}
, K+ Q' J$ M! \, Y我们还需要一个新的方法来增加Nonce,直到我们获得一个有效hash。强调一下,这是由难度决定的。所以我们会收到作为参数的难度。
  D* k) c! z$ |mineBlock(difficulty) {
' V7 m% R+ W1 `7 h4 X' Q4 t+ a& U" O    while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")) {
8 O: g4 M: {5 L        this.nonce++;
' S* W3 Z$ ^" |/ m0 a        this.hash = this.calculateHash();
& X3 V# r( X; J; ]4 |& M! |9 C    }
5 C& x( [) H5 r    console.log("BLOCK MINED: " + this.hash);
2 r5 w6 |2 H7 v: y. Q+ F" Y7 p}: J. x5 Q& j. `
最后,我们还需要更改一下calculateHash()函数。因为目前他还没有使用Nonce来计算hash。3 b: s7 s) I  ?+ s6 j& s1 m& k* ^
calculateHash() {  C- q% s. w) v+ {
  return SHA256(this.index +) x, [4 ?2 f& f' P# p
    this.previousHash +0 w- K9 o( U0 ?1 _
    this.timestamp +7 N+ h. G( U; I/ \' s8 C$ ~1 A
    JSON.stringify(this.data) +
* t/ E2 a7 \$ o" |# f; t    this.nonce8 n/ v4 L: z/ s3 ~* }( H
  ).toString();4 b3 T6 F0 b: B1 G; z
}" s- n' a, f5 Q+ M1 V- o/ O
将它们结合在一起,你会得到如下所示的区块类:/ @: C) \. |9 d% L
class Block {  h- ~; A4 M! u6 H+ `  Q2 _
  constructor(index, timestamp, data, previousHash = '') {
8 @' M; z$ p2 A    this.index = index;0 x! t! H$ J$ z( a. D
    this.previousHash = previousHash;0 T4 O7 G1 d; X5 L, Y
    this.timestamp = timestamp;
! t( ?) g' w" l+ {    this.data = data;: H3 M) y0 @  o0 Z
    this.hash = this.calculateHash();4 q( _6 u% C2 h- F  w! o
    this.nonce = 0;" r2 X% a/ F# O
  }
# l. K. p' d* ?; I  calculateHash() {. ?, A  f% m0 z+ S+ E
    return SHA256(this.index + this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce).toString();6 W5 T: `9 o4 J2 Z6 Y
  }2 {, [; ~! A- G6 H1 P+ \
  mineBlock(difficulty) {. v( u) L# a. R; R
    while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")) {
( j; w. D4 }; r: h1 t/ F9 I      this.nonce++;
$ W* x  p0 D7 O      this.hash = this.calculateHash();" Z9 M- G6 P# W$ E" `- V
    }
: H4 H, _: X# j" V6 t( {; I& m/ f6 B    console.log("BLOCK MINED: " + this.hash);
, D7 U! y' r- L5 {  }& {( H2 Q. {- n& V, p4 _& a
}
2 P% W& T; @- C0 W0 C' F6 D修改区块链7 F( `% H+ ~6 Y) T" F
现在,我们的区块已经拥有Nonce并且可以被开采了,我们还需要确保我们的区块链支持这种新的行为。让我们先在区块链中添加一个新的属性来跟踪整条链的难度。我会将它设置为2(这意味着区块的hash必须以2个0开头)。# y6 b$ d: G' V9 [& A: ?+ {
constructor() {' X/ H0 K, s" b" L5 k+ t
  this.chain = [this.createGenesisBlock()];$ e, E* X$ n: N6 V
  this.difficulty = 2;
+ V+ n+ A+ W( r6 m  I}$ j, k3 ?* P5 x( L1 L. O
现在剩下要做的就是改变addBlock()方法,以便在将其添加到链中之前确保实际挖到该区块。下面我们将难度传给区块。
' E4 ?5 l; R( z% v2 M' ~$ x5 raddBlock(newBlock) {
+ D2 f9 F  l3 i) @) q4 f& _' M  r7 y7 Y  newBlock.previousHash = this.getLatestBlock().hash;9 l- ], G: K9 f6 E( q
  newBlock.mineBlock(this.difficulty);
- d0 b0 @# ~4 @! O, a* z  this.chain.push(newBlock);* M# T: x! C% Q  K3 L
}' ^/ d4 {3 W% r! A6 w: N/ k: M
大功告成!我们的区块链现在拥有了POW来抵御攻击了。$ Z) E& ?6 A6 }( i" R- _7 u
测试
, l7 D% k1 w( E9 O' @现在让我们来测试一下我们的区块链,看看在POW下添加一个新区块会有什么效果。我将会使用之前的代码。我们将创建一个新的区块链实例然后往里添加2个区块。2 N3 I3 z5 R7 s1 d6 f: Z
let savjeeCoin = new Blockchain();% h& M( I: J) D1 f0 U
console.log('Mining block 1');( @! U% k5 F3 {  A+ D. O6 W
savjeeCoin.addBlock(new Block(1, "20/07/2017", { amount: 4 }));
, l5 A& p; Y5 S! y; W" Rconsole.log('Mining block 2');: S* c* O. N9 F; J; N( s
savjeeCoin.addBlock(new Block(2, "20/07/2017", { amount: 8 }));7 `$ E- Z, I7 f  J" r+ m
如果你运行了上面的代码,你会发现添加新区块依旧非常快。这是因为目前的难度只有2(或者你的电脑性能非常好)。  P: K1 b/ b) y9 O1 ~  `
如果你创建了一个难度为5的区块链实例,你会发现你的电脑会花费大概十秒钟来挖矿。随着难度的提升,你的防御攻击的保护程度越高。
  P: S' x% v- k免责声明) U8 |6 C4 v7 Y' y- {& p) {+ W
就像之前说的:这绝不是一个完整的区块链。它仍然缺少很多功能(像P2P网路)。这只是为了说明区块链的工作原理。; s" d5 O  i& S( d0 |0 q
并且:由于单线程的原因,用JavaScript来挖矿并不快。" \9 S# a* T& D; Y' \
Part3 交易与挖矿奖励% e- S8 H4 Y% {: O
在前面两部分我们创建了一个简单的区块链,并且加入了POW来抵御攻击。然而我们在途中也偷了懒:我们的区块链只能在一个区块中存储一笔交易,而且矿工没有奖励。现在,让我们解决这个问题!2 d  I1 M) r' ^
重构区块类
! |: U. j7 R3 X3 }' `* ]1 G9 |" u现在一个区块拥有index,previousHash,timestamp,data,hash和nonce属性。这个index属性并不是很有用,事实上我甚至不知道为什么开始我要将它添加进去。所以我把它移除了,同时将data改名为transactions来更语义化。
( z4 f; R. {7 i$ O+ w/ Cclass Block{
/ Y7 \# \9 O  Z: o+ Z+ ?6 j& q  constructor(timestamp, transactions, previousHash = '') {: ?3 Y" u+ e, X, @. L
    this.previousHash = previousHash;, a8 {1 m! P; e; A! N/ l1 o6 _8 i
    this.timestamp = timestamp;
: r( o! w( x; t6 V# S  o    this.transactions = transactions;% q4 D# `" d. S; s2 u
    this.hash = this.calculateHash();8 e  A2 K0 N9 E; C6 j& a
    this.nonce = 0;" H1 O1 @7 v$ w
  }
" ^1 j3 ~* P) f, N" H5 R}' V. ?; E- f6 ^* I' F3 h- A  \! m
当我们改变区块类时,我们也必须更改calculateHash()函数。现在它还在使用老旧的index和data属性。
) l4 P5 j9 K$ I. E0 ?9 {0 u. i' `. KcalculateHash() {+ {9 @! T, ?, ~, U; Z0 L# Y  J
  return SHA256(this.previousHash + this.timestamp + JSON.stringify(this.transactions) + this.nonce).toString();
1 a" v; J% a* z8 ^8 k( u4 O# P, w}/ q/ P/ F- |' X+ Y1 w. A) C/ @
交易类
' J* j  |# z3 E在区块内,我们将可以存储多笔交易。因此我们还需要定义一个交易类,一边我们可以锁定交易应当具有的属性:
) r. z! t+ }: a1 [7 {  |class Transaction{3 S0 ?. @& a7 w, j# f7 R
  constructor(fromAddress, toAddress, amount){, h1 l, f( P' G, h7 a7 _
    this.fromAddress = fromAddress;% ~, L& b0 P/ l! S
    this.toAddress = toAddress;, B; @/ ~5 Z: x/ s
    this.amount = amount;
( G7 Q6 x4 j. N% ^1 V2 G" e- D  }
$ E, s) z$ H6 c4 P+ R' s}
1 Q: Z7 X# v+ \; ^0 s1 e  t这个交易例子非常的简单,仅仅包含了发起方(fromAddress)和接受方(toAddress)以及数量。如果有需求,你也可以在里面加入更多字段,不过这个只是为了最小实现。
; Z$ Z2 t2 o' e2 l9 m/ J调整我们的区块链, A3 F/ I: @& i6 w9 f
当前的最大任务:调整我们的区块链来适应这些新变化。我们需要做的第一件事就是存储待处理交易的地方。
5 |, X, \* U9 x+ i0 q& r正如你所知道的,由于POW,区块链可以稳定的创建区块。在比特币的场景下,难度被设置成大约每10分钟创建一个新区块。但是,是可以在创造两个区块之间提交新的交易。
1 D& ~  t& T6 z为了做到这一点,首先需要改变我们区块链的构造函数,以便他可以存储待处理的交易。我们还将创造一个新的属性,用于定义矿工获得多少钱作为奖励:9 u4 }5 N2 k/ l+ l! i3 V* q% \
class Blockchain{
6 d+ O, T/ _* x  constructor() {) x8 v6 g% v* t( A) x* \: ]2 b  n' L
    this.chain = [this.createGenesisBlock()];. h9 L+ M5 `+ j' R" L* v1 {0 q
    this.difficulty = 5;
1 E7 f. A2 D5 b    // 在区块产生之间存储交易的地方' g+ l6 _6 P3 I! L+ @; l' U; g9 S
    this.pendingTransactions = [];
# W; D* i1 \" x5 Z    // 挖矿回报( I: ~7 e. X3 h/ J9 i0 Y5 L
    this.miningReward = 100;
: E- v8 a: }/ h: i) @2 Q  }
# x$ T( O# }3 z! @" J2 j5 P}
/ Z( D  @# n/ l下一步,我们将调整我们的addBlock()方法。不过我的调整是指删掉并重写它!我们将不再允许人们直接为链上添加区块。相反,他们必须将交易添加至下一个区块中。而且我们将addBlock()更名为createTransaction(),这看起来更语义化:
) r% K; t: d# M2 n4 j% y/ b3 J; G3 ocreateTransaction(transaction) {
. `$ j6 {5 z6 U% O  // 这里应该有一些校验!2 O/ K: e% a, y" x$ B+ y+ F; w; S- n
  // 推入待处理交易数组
4 X6 g/ Z* z8 H  {! j, Z/ j# u' w  this.pendingTransactions.push(transaction);3 p* [$ j- c+ ?
}
/ Z; W; U: p! \% j4 Z3 ^  l挖矿
% E7 ?" [" s2 X- s: G; ^( q7 \人们现在可以将新的交易添加到待处理交易的列表中。但无论如何,我们需要将他们清理掉并移入实际的区块中。为此,我们来创建一个minePendingTransactions()方法。这个方法不仅会挖掘所有待交易的新区块,而且还会向采矿者发送奖励。8 X+ f2 b1 O9 K0 U
minePendingTransactions(miningRewardAddress) {; c6 g8 @% ^9 B& q; e7 _
  // 用所有待交易来创建新的区块并且开挖..
+ s+ y  r6 t+ |/ D  let block = new Block(Date.now(), this.pendingTransactions);
  B: }+ k# K$ }* Q  block.mineBlock(this.difficulty);: Y) [9 H- R- I+ g1 z  m% W0 S
  // 将新挖的看矿加入到链上* D' g% E1 T6 F- P: s! I
  this.chain.push(block);
8 B' _( o- B$ C, h) i  // 重置待处理交易列表并且发送奖励8 I- V5 G$ z. Z! d. k( d
  this.pendingTransactions = [: Y$ C/ H/ a- B5 A# O- N
      new Transaction(null, miningRewardAddress, this.miningReward)7 _! W9 \4 m  a% w: g
  ];
3 t3 G9 y0 h6 t}# Z9 i" F/ Q) l( n% k0 C" w6 Y
请注意,该方法采用了参数miningRewardAddress。如果你开始挖矿,你可以将你的钱包地址传递给此方法。一旦成功挖到矿,系统将创建一个新的交易来给你挖矿奖励(在这个栗子里是100枚币)。
1 n7 c9 P% }7 d2 z4 B: g有一点需要注意的是,在这个栗子中,我们将所有待处理交易一并添加到一个区块中。但实际上,由于区块的大小是有限制的,所以这是行不通的。在比特币里,一个区块的大小大概是2Mb。如果有更多的交易能够挤进一个区块,那么矿工可以选择哪些交易达成哪些交易不达成(通常情况下费用更高的交易容易获胜)。8 N: V8 E7 v' |  m& H; t, f4 s
地址的余额
# C9 N4 j. y7 b* R! {在测试我们的代码钱让我们再做一件事!如果能够检查我们区块链上地址的余额将会更好。# L, Q+ V  Y7 X. M: V; c8 x2 p
getBalanceOfAddress(address){
2 N6 L  q# H* w, R( R) G  let balance = 0; // you start at zero!
/ L" X, R- h  A- \  // 遍历每个区块以及每个区块内的交易/ }& z: }% H+ N! g' V
  for(const block of this.chain){& [; Z8 ]: Q. O" j6 r, L
    for(const trans of block.transactions){
8 Q* s# R) l/ _      // 如果地址是发起方 -> 减少余额
% n9 ^# |1 ?$ ^      if(trans.fromAddress === address){6 b, Z5 C/ R$ |, K
        balance -= trans.amount;0 I! Y2 k% Y9 D( ?; e  G! E7 |
      }& t1 @+ D2 p6 F1 \
      // 如果地址是接收方 -> 增加余额) g  C" H( J- H. k1 Z4 U
      if(trans.toAddress === address){# Y- j, W4 f  \$ o0 p
        balance += trans.amount;1 r7 S+ g/ v, Y. t6 S
      }  r! ]1 H* Y( o  v6 r5 ^
    }3 z) R+ d) S+ K/ f' p* [9 y
  }
) B% P8 x9 }8 |! p/ Z  return balance;
7 c" x; E  ^. R/ g}  I' _" ~4 x$ y9 V) c6 w& c+ o- J
测试
7 ^5 Z1 w$ b6 e( j好吧,我们已经完成并可以最终一切是否可以正常工作!为此,我们创建了一些交易:
2 A. \" ^$ [7 c" _  C  _- alet savjeeCoin = new Blockchain();9 r7 ?  _) M: S+ B. D0 A! U
console.log('Creating some transactions...');0 `; C2 ]3 g# i: ~% `" K- {
savjeeCoin.createTransaction(new Transaction('address1', 'address2', 100));
% `0 R; N! q5 }( z# \- B% SsavjeeCoin.createTransaction(new Transaction('address2', 'address1', 50));
+ I( R/ {+ ]; C8 s& W, W' d% l这些交易目前都处于等待状态,为了让他们得到证实,我们必须开始挖矿:
/ ]2 v' w( w8 [console.log('Starting the miner...');
1 D+ Y. w, J, s1 i3 v) E& F: RsavjeeCoin.minePendingTransactions('xaviers-address');# C+ j2 Q8 n6 w3 H
当我们开始挖矿,我们也会传递一个我们想要获得挖矿奖励的地址。在这种情况下,我的地址是xaviers-address(非常复杂!)。  a' ]7 M, b# w; M! i
之后,让我们检查一下xaviers-address的账户余额:8 }2 v4 q8 ?7 a9 Z8 M  B) o2 O" u
console.log('Balance of Xaviers address is', savjeeCoin.getBalanceOfAddress('xaviers-address'));
! C7 V- R3 T- A. n6 v3 b7 a  S// 输出: 0) j5 |, t* E& {; p, J* t6 b: @
我的账户输出竟然是0?!等等,为什么?难道我不应该得到我的挖矿奖励么?那么,如果你仔细观察代码,你会看到系统会创建一个交易,然后将您的挖矿奖励添加为新的待处理交易。这笔交易将会包含在下一个区块中。所以如果我们再次开始挖矿,我们将收到我们的100枚硬币奖励!
  B! e% c' @$ W/ j1 Z- A1 tconsole.log('Starting the miner again!');7 y- ^; f* c2 ]% E  {. o$ O2 ^
savjeeCoin.minePendingTransactions("xaviers-address");
9 y9 u  K) o2 [4 b8 X6 ~! Aconsole.log('Balance of Xaviers address is', savjeeCoin.getBalanceOfAddress('xaviers-address'));4 w& }/ j1 l3 _! ?& l0 A) B
// 输出: 100$ v+ K' [- a6 x! `0 t
局限性与结论8 U1 ~5 B' e6 d  H$ t
现在我们的区块链已经可以在一个区块上存储多笔交易,并且可以为矿工带来回报。
8 X- R. Q1 m- g0 R& ~9 `+ [不过,还是有一些不足:发送货币是,我们不检查发起人是否有足够的余额来实际进行交易。然而,这其实是一件容易解决的事情。我们也没有创建一个新的钱包和签名交易(传统上用公钥/私钥加密完成)。5 Q, n' v- t& |8 c% D+ |
免责声明 & 源代码
; ?. `+ r+ V1 o5 b: K6 O% T我想指出的是,这绝不是一个完整的区块链实现!它仍然缺少很多功能。这只是为了验证一些概念来帮助您来了解区块链的工作原理。! h2 H( ^  G- b) t
该项目的源代码就放在我的GitHub
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

Kierra34656 小学生
  • 粉丝

    0

  • 关注

    0

  • 主题

    1