使用Javascript实现简单的小型区块链

区块链概念

狭义：区块链是一种按照时间顺序将数据区块以顺序相连的方式组合成的一种链式数据结构，并以密码方式保证的不可篡改和不可伪造的分布式账本。

一、挖矿（产生新区块）

首先，区块链是由每一个区块联系而形成的，在产生新区块之前必须先有一个最初始的区块，这个区块也叫创世区块。通过这个创世区块，不停地通过变化随机数（nonce）来计算出符合条件的区块。以下是创世区块基本信息：

1. const initBlock = {  
2.     index: 0,  
3.     data: 'hey，this is a block chain',  
4.     previousHash: '0',  
5.     timestamp: '1551806536961',  
6.     nonce: 80490,  
7.     hash: '0000352fb27dd1141fa7265833190a53e5776b1111e275db0d9a77bf840081e6'  
8. }; 

1.   index：是指每个区块的序号
2.   data： 这里存放着区块中所有的信息，例如转账，余额等数据
3.   previousHash： 指的是上一个区块的hash值，创世区块没有上一个，显示0即可
4.   timestamp：指的是创建这个区块的时间
5.   nonce：这个是随机数，挖矿就是通过不停变换这个nonce来计算出符合条件的哈希。
6.   hash： 本区块的hash值，通过前面5个字段的信息进行hash运算得出的值。

接着，通过不停的hash运算计算出符合条件的哈希，即挖矿。挖矿也可以调节难度的大小，例如算出的哈希值必须前3位数必须为1或者末3位数必须为1等等，这个可以自行的去定义，只要***留一个控制的开关，方便控制即可。可以在定义一个变量

哈希的计算：

1. .createHash('sha256')  
2.  .update(index + data + previousHash + timestamp + nonce)  
3.  .digest('hex')  

1. _that.difficulty = 3 // 即前3位或者末3位数必须为1，数量越多难度越大 

生成了符合条件的hash之后，则产生了新的区块，但是还要对这个区块进行校验看看是否有效，因为可能这是一个被篡改的非法的区块，也有可能和这个链没有任何关系的区块而仅仅只是符合上述哈希的规则而已。所以，需要进行一下校验,,前后区块的有效性。

1. isValidaBlock(newBlock,lastBlock) {  
2.      if (newBlock.index !== lastBlock.index+1) return false  
3.      if (newBlock.previousHash !== lastBlock.hash) return false  
4.      if (newBlock.timestamp <= lastBlock.timestamp) return false  
5.      if (newBlock.hash.slice(1 ,_that.difficulty) !== '1'.repeat(_that.difficulty)) return false  
6.      if (newBlock.hash !== this.computeHashForBlock(newBlock)) return false  //确保随机数正确  
7.         // 都满足则返回true  
8.         return true  
9.     } 

除了上面的校验之外，还需要使用上面这个函数对整一个chain进行一个每一个块的校验，以保证每一个块的信息是正确的，是没有被篡改过的是合法的。

二、构建P2P网络

区块链的网络是去中心化的，即没有中心服务器的网络，客户端不需要依赖中心服务器来获取或者处理数据。区块链网络中，有这许许多多的节点，每个节点都是一个独立的成员，他们既是客户端也是服务器，节点与节点直接都是点对点进行连接（peer-to-peer），不需要通过某一个中心服务器进行中转，所以，信息安全的角度来说，点对点的连接方式对信息私密性是非常可靠的。

虽然，区块链是通过点对点的连接方式进行数据传输，但是，在这之前还需要一个东西作为引导，这个就是种子节点。因为，两个节点之间他们可能不是处在同一个域下，他们之间想要联系，必须有一方知道对方的ip和端口，这样才能和对方联系上。节点ip和端口号，在这个节点创建出来之后，种子节点就会发给它在这个区块链中所有节点的ip和端口号同时记录下这个新伙伴的ip和端口号。那么，新的节点拿到了这一份"通讯录"之后，就会给这个"通讯录"中的所有小伙伴发个消息，告诉他们有一位新的小伙伴加入，之后，其他节点收到了这个信息，也会在自己的"通讯录"中加上新伙伴的ip和端口号，相当于加入了白名单。这样新的节点接下来就可以和任意的的节点进行通信了。

下面用代码演示一下：

1. (res)=>{  
2.   _that.remotePeerInfo = res.data.data   //1  
3.   _that.addPeersList(res.peersList)             //2  
4.   _that.boardCast(_that.remotePeerInfo)    //3  
5.   _that.blockChainUpdate(blockChain,blockData)     //4  
6. }  
7. addPeersList(peers) {  
8.     peers.forEach(peer => {  
9.         if (!_that.peers.find(v => _that.isEqualPeer(peer, v))) {  
10.             _that.peers.push(peer)  
11.         }  
12.     })  
13. }  
14. boardCast(remotePeerInfo) {  
15.     this.peers.forEach(v => {  
16.         this.send(action, v.port, v.address)  
17.     })  
18. }  
19. blockChainUpdate(blockChain,blockData){  
20.   if(newChain.length === 1 ){  
21.     return  
22.     }  
23.     if(_that.isValidaChain(newChain) && newChain.length>_that.blockchain.length){  
24.     _that.blockchain = Object.assign({}, newChain)  
25.     }else{  
26.     console.log('error')  
27.     return  
28.     }  
29.     if (trans.every(v => _that.isValidTransfer(v))) {  
30.     _that.data = trans  
31.     } 
32. } 

1.保存种子节点传来的此新节点的信息包括ip和端口号，因为，新节点的ip和端口号是会有改变的情况。

2.接受种子节点传来的节点列表，将列表的节点遍历检查一下，没有相同的就写进列表中。

3.将新节点的信息广播到所有的节点上，同时接受到信息的节点更新一下节点列表

4.将区块链上信息同步一份都本地，同时对种子节点传来的blockchain进行每个区块的信息

三、转账交易

BTC的交易模型是使用的是UTXO。

而这个小型区块链的交易模型使用的是最简单的方法。

区块链中"现金”，它是一个虚拟的东西就是一个字符串，来源于挖矿。每次挖矿成功都会有一定的奖励，得到的这些“钱”就可以在区块链网络中自由的转账交易。

在区块链中，进行记录转账交易的时候是需要一个加密的算法，把所有的信息进行加密之后再push到新区块中的data中，从而完成一笔新交易的记录。以BTC为例，BTC的加密算法是使用elliptic这个加密算法，elliptic是一个非对称性的加密算法，非对称的加密算法的特点就是，私钥是惟一的，只有拥有者才可以和他私钥对应的公钥进行校验 。 nodejs也有对应的库在github上搜索elliptic即可。

1. {  
2.   "privateKey": "34a425df3eb1f22fb6cb74b0e7298b16ffd7f3fb",  
3.   "publicKey": "ac208623a38d2906b090dbcf3a09378dfe79b77bf39c2b753ef98ea94fe08dc3995a1bd05c917"  
4. } 

上面是一个生成好的密钥对格式，仅作为展示，我删减了一部分长度。

使用银行卡进行转账交易的时候，会有一个转出的账号和一个转入的账号，在区块链中的记账也会有这个账号，这个账号就是上面使用生成的密钥对中的公钥，公钥就是地址，或者说公钥代表的就是自己的钱包。

校验的方法，首先使用字段“from”，“to”，“amount”的参数进行sign签名，然后在每次挖矿（记账）的时候，则使用verify(),通过前面的三个参数，和sig进行校验

1. verify(type,data){  
2.     swtich(type){  
3.         case 'sign':  
4.             const bufferMsg = Buffer.from(`${data.from}-${data.to}-${data.amount}`)  
5.             let signature = Buffer.from(keypair.sign(bufferMsg).toDER()).toString('hex')  
6.                this.signature =  signature  
7.         break;  
8.         case 'verify':  
9.              const keypairTemp = ec.keyFromPublic(pub, 'hex')  
10.                 const bufferMsg = Buffer.from(`${data.from}-${data.to}-${data.amount}`)  
11.              this.keypair = keypairTemp.verify(bufferMsg, sig)  
12.         break;  
13.         default;  
14.     }  
15. } 

转帐的时候需要3步，分别是校验转出账户是否有足够的金额，转出账户就是本地公钥。如有则进行记账并且使用两个地址、金额、时间，还有签名加密打包，之后进行全节点广播。其他节点收到这个信息之后***件事也是对新区块的有效性做一个校验，通过校验之后就会写入data中。

1. transfer(data)  {  
2.     const timestamp = new Date().getTime()  
3.     const sig = rsa.sign({data.from, data.to, data.amount , timestamp})  
4.     const sigTrans = {data.from, data.to, data.amount ,timestamp, sig }   
5.         // 非创世区块  
6.     if (trans.from !== '0') {  
7.             // 检验余额  
8.         if (!(_that.blance < amount)) { //_that.blance 当前账户余额  
9.             //全节点广播  
10.             _that.send('trans', sigTrans)  
11.         }else{  
12.             console.log('not enough blance')  
13.             return  
14.         }  
15.     }  
16.     this.data.push(sigTrans)  
17.     return sigTrans  
18. } 

其他节点收到消息之后，先进行去重校验，然后再更新数据。

四、查询余额

这个链的查询方法比较简单，就是将区块中的每一条交易的信息进行校验和匹配，满足条件的就进行增减，同时忽略精度上的问题。

1. this.blance = blance(address)  
2. blance(address) {  
3.        let blance = 0;  
4.        this.blockchain.forEach(block => {  
5.            block.data.forEach(trans => {  
6.                if (address == trans.from) {  
7.                    blance -= trans.amount  
8.                }  
9.                if (address == trans.to) {  
10.                    blance += trans.amount 
11.                }  
12.            })  
13.        });  
14.        return blance  
15.    } 

至此，区块链的最简单的功能就实现完毕