前言

  区块链太复杂，那我们就讲点简单的。用JS来构建你自己的区块链系统，寥寥几行代码就可以说明区块链的底层数据结构、POW挖矿思想和交易过程等。当然了，真实的场景远远远比这复杂。本文的目的仅限于让大家初步了解、初步认识区块链。
 

文章内容主要参考视频： Building a blockchain with Javascript ( https://www.youtube.com/playlist?list=PLzvRQMJ9HDiTqZmbtFisdXFxul5k0F-Q4)

感谢原作者，本文在原视频基础上做了修改补充，并加入了个人理解。

认识区块链

区块链顾名思义是由区块连接而成的链，因此最基本的数据结构是Block。每个Block都含有timestamp、data、hash、previousHash等信息。其中data用来存储数据，previousHash是前一个区块的hash值。示意如下：

1543399023366-4e873559-f595-4687-a01d-75

  hash是对区块信息的摘要存储，hash的好处是任意长度的信息经过hash都可以映射成固定长度的字符串，如可用sha256：
 

calculateHash() {
    return SHA256(this.previousHash+ this.timestamp + JSON.stringify(this.data)).toString();
}

Block的数据结构

Block的最基本数据结构如下：

class Block {
    constructor(timestamp, data, previousHash = '') {
        this.timestamp = timestamp;
        this.data = data;
        this.previousHash = previousHash;
        //对hash的计算必须放在最后，保证所有数据赋值正确后再计算
        this.hash = this.calculateHash(); }

calculateHash() {
        return SHA256(this.previousHash + this.timestamp + JSON.stringify(this.data)).toString();
    }
}

BlockChain的数据结构

多个Block链接而成BlockChain，显然可用用数组或链表来表示，如：

class BlockChain {
    constructor() {
        this.chain = [];
    }
}

创世区块

正所谓万物始于一，区块链的第一个区块总是需要人为来手动创建，这个区块的previousHash为空，如：

createGenesisBlock() {
    return new Block("2018-11-11 00:00:00", "Genesis block of simple chain", "");
}

区块链的构造方法也应改为：

class BlockChain {
    constructor() {
        this.chain = [this.createGenesisBlock()];
    }
}

添加区块

每新加一个区块，必须保证与原有区块链连接起来，即：

class BlockChain {
    getLatestBlock() {
        return this.chain[this.chain.length - 1];
    }
    
    addBlock(newBlock) {
        //新区块的前一个hash值是现有区块链的最后一个区块的hash值；
        newBlock.previousHash = this.getLatestBlock().hash;
        //重新计算新区块的hash值（因为指定了previousHash)；
        newBlock.hash = newBlock.calculateHash(); 
        //把新区块加入到链中；
        this.chain.push(newBlock); 
    }
    ...
}

校验区块链

区块链数据结构的核心是保证前后链接、无法篡改，但是如果有人真的篡改了某个区块，我们该如何校验发现呢？最笨也是最自然是想法就是遍历所有情况，逐一校验，如：

isChainValid() {
    //遍历所有区块
    for (let i = 1; i < this.chain.length; i++) {
        const currentBlock = this.chain[i];
        const previousBlock = this.chain[i - 1];
        //重新计算当前区块的hash值，若发现hash值对不上，说明该区块有数据被篡改，hash值未重新计算
        if (currentBlock.hash !== currentBlock.calculateHash()) {
            console.error("hash not equal: " + JSON.stringify(currentBlock));
            return false;
        }
        //判断当前区块的previousHash是否真的等于前一个区块的hash，若不等，说明前一个区块被篡改，虽然hash值被重新计算正确，但是后续区块的hash值并未重新计算，导致整个链断裂
        if (currentBlock.previousHash !== previousBlock.calculateHash) {
            console.error("previous hash not right: " + JSON.stringify(currentBlock));
            return false;
        }
    }
    return true;
}

Just run it

跑起来看看，即：

let simpleChain = new BlockChain();
simpleChain.addBlock(new Block("2018-11-11 00:00:01", {amount: 10}));
simpleChain.addBlock(new Block("2018-11-11 00:00:02", {amount: 20}));


console.log(JSON.stringify(simpleChain, null, 4));

console.log("is the chain valid? " + simpleChain.isChainValid());

结果如下：

ali-186590cc4a7f:simple-chain shanyao$ node main_1.js 
{
    "chain": [
        {
            "timestamp": "2018-11-11 00:00:00",
            "data": "Genesis block of simple chain",
            "previousHash": "",
            "hash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89"
        },
        {
            "timestamp": "2018-11-11 00:00:01",
            "data": {
                "amount": 10
            },
            "previousHash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89",
            "hash": "150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529"
        },
        {
            "timestamp": "2018-11-11 00:00:02",
            "data": {
                "amount": 20
            },
            "previousHash": "150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529",
            "hash": "274a7a13ed20118e8cb745654934a7e24a4d59333ba17dfbf5d4cfe0fa8a6e34"
        }
    ]
}
is the chain valid? true

注意看其中的previousHash与hash，确实是当前区块的previousHash指向前一个区块的hash。

篡改下试试

都说区块链不可篡改，是真的吗？让我们篡改第2个区块试试，如：

let simpleChain = new BlockChain();
simpleChain.addBlock(new Block("2018-11-11 00:00:01", {amount: 10}));
simpleChain.addBlock(new Block("2018-11-11 00:00:02", {amount: 20}));

console.log("is the chain valid? " + simpleChain.isChainValid());

//将第2个区块的数据，由10改为15
simpleChain.chain[1].data = {amount: 15};

console.log("is the chain still valid? " + simpleChain.isChainValid());
console.log(JSON.stringify(simpleChain, null, 4));

结果如下：

ali-186590cc4a7f:simple-chain shanyao$ node main_1.js 
is the chain valid? true
hash not equal: {"timestamp":"2018-11-11 00:00:01","data":{"amount":15},"previousHash":"fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89","hash":"150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529"}
is the chain still valid? false
{
    "chain": [
        {
            "timestamp": "2018-11-11 00:00:00",
            "data": "Genesis block of simple chain",
            "previousHash": "",
            "hash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89"
        },
        {
            "timestamp": "2018-11-11 00:00:01",
            "data": {
                "amount": 15
            },
            "previousHash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89",
            "hash": "150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529"
        },
        {
            "timestamp": "2018-11-11 00:00:02",
            "data": {
                "amount": 20
            },
            "previousHash": "150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529",
            "hash": "274a7a13ed20118e8cb745654934a7e24a4d59333ba17dfbf5d4cfe0fa8a6e34"
        }
    ]
}

显然，篡改了数据之后，hash值并未重新计算，导致该区块的hash值对不上。

再篡改下试试

那么，如果我们聪明点，篡改后把hash值也重新计算会如何？

let simpleChain = new BlockChain();
simpleChain.addBlock(new Block("2018-11-11 00:00:01", {amount: 10}));
simpleChain.addBlock(new Block("2018-11-11 00:00:02", {amount: 20}));

console.log("is the chain valid? " + simpleChain.isChainValid());
//篡改后重新计算hash值
simpleChain.chain[1].data = {amount: 15};
simpleChain.chain[1].hash = simpleChain.chain[1].calculateHash();
console.log("is the chain still valid? " + simpleChain.isChainValid());
console.log(JSON.stringify(simpleChain, null, 4));

结果如下：

ali-186590cc4a7f:simple-chain shanyao$ node main_1.js 
is the chain valid? true
previous hash not right: {"timestamp":"2018-11-11 00:00:02","data":{"amount":20},"previousHash":"150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529","hash":"274a7a13ed20118e8cb745654934a7e24a4d59333ba17dfbf5d4cfe0fa8a6e34"}
is the chain still valid? false
{
    "chain": [
        {
            "timestamp": "2018-11-11 00:00:00",
            "data": "Genesis block of simple chain",
            "previousHash": "",
            "hash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89"
        },
        {
            "timestamp": "2018-11-11 00:00:01",
            "data": {
                "amount": 15
            },
            "previousHash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89",
            "hash": "74d139274fb692495b7c805dd5822faa0c5b5e6058b6beef96e87e18ab83a6b1"
        },
        {
            "timestamp": "2018-11-11 00:00:02",
            "data": {
                "amount": 20
            },
            "previousHash": "150b196268a0152e9f0e719ac131a722472a809f49bd507965029a78c7400529",
            "hash": "274a7a13ed20118e8cb745654934a7e24a4d59333ba17dfbf5d4cfe0fa8a6e34"
        }
    ]
}

显然，第3个区块的previousHash并未指向第2个区块的hash。

是真的无法篡改吗

其实并不是，如果我们再聪明一点，把后续区块的hash值也重新计算一下，不就OK了吗？确实如此，如：

let simpleChain = new BlockChain();
simpleChain.addBlock(new Block("2018-11-11 00:00:01", {amount: 10}));
simpleChain.addBlock(new Block("2018-11-11 00:00:02", {amount: 20}));

console.log("is the chain valid? " + simpleChain.isChainValid());
//篡改第2个区块
simpleChain.chain[1].data = {amount: 15};
simpleChain.chain[1].hash = simpleChain.chain[1].calculateHash();
//并把第3个区块也重新计算
simpleChain.chain[2].previousHash = simpleChain.chain[1].hash;
simpleChain.chain[2].hash = simpleChain.chain[2].calculateHash();
console.log("is the chain still valid? " + simpleChain.isChainValid());
console.log(JSON.stringify(simpleChain, null, 4));

结果如下：

ali-186590cc4a7f:simple-chain shanyao$ node main_1.js 
is the chain valid? true
is the chain still valid? true
{
    "chain": [
        {
            "timestamp": "2018-11-11 00:00:00",
            "data": "Genesis block of simple chain",
            "previousHash": "",
            "hash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89"
        },
        {
            "timestamp": "2018-11-11 00:00:01",
            "data": {
                "amount": 15
            },
            "previousHash": "fd56967ff621a4090ff71ce88fdd456547d1c92d2e93766b7e8791f7a5f91f89",
            "hash": "74d139274fb692495b7c805dd5822faa0c5b5e6058b6beef96e87e18ab83a6b1"
        },
        {
            "timestamp": "2018-11-11 00:00:02",
            "data": {
                "amount": 20
            },
            "previousHash": "74d139274fb692495b7c805dd5822faa0c5b5e6058b6beef96e87e18ab83a6b1",
            "hash": "cc294e763c51e9357bf22d96073e643f4d51e07dd0de6e9b15d1d4f6bf6b45a8"
        }
    ]
}

现在看来，整个区块链确实完全被篡改了！！！事实上，如果你能做到篡改某个区块的时候，把后续所有的区块一起篡改掉，即可把整个区块链篡改掉。只不过，有的时候后续区块很多，你还要篡改的足够快，篡改的成本也非常高。因此，区块链并非完全不能被篡改，篡改是有“价格”的，更多是经济学上的考虑。在区块链的设计上，会尽可能地提高篡改的成本，让篡改的成本远远大于篡改的潜在收益，这样，整个区块链就可以被认为是安全的、不可篡改的。

工作量证明（Proof-of-Work）让区块链更安全

  如前所述，区块链并非完全不可篡改，只是要提高篡改的成本。那如何提高成本呢？最笨的办法似乎就是人为地设置障碍，即：你想参与记账吗？那请先把这道复杂的数学题解出来，以证明你的实力和意愿。这就是最简单最朴素的工作量证明的思想。
 

出一道题

  是什么样的数学题呢？并不是什么高深的题目，只是看起来傻傻的，只能靠猜、靠试才能解决的题目，比如：请保证hash值的前10位全是0。
 

  大家都知道，hash计算具备如下典型特征：
 

任意长度的信息，不管是一句话、一篇文章、还是一首歌，都可以计算出唯一的一串数字与之对应。
这串数字的长度是固定的。
计算过程是不可逆的，即你可以很容易计算出一段文本的hash值，但是你没有办法知道某个hash值对应的原始信息是什么。

因此，如果给你一段文本，允许你在文本最后加上一个随机数（nonce)，来保证这段文本+随机数的hash值的前10位都是0，你没有什么好办法，只能不断地尝试不同的数字，然后期盼着运气好的话，能尽快试出来。

为区块增加随机数nonce

  前面区块的hash计算是固定的，即：
 

calculateHash() {
        return SHA256(this.previousHash + this.timestamp + JSON.stringify(this.data)).toString();
  }

  该值无法改变，为了保证能解题，需要人为地在区块中加入随机数，即：
 

constructor(timestamp, data, previousHash = '') {
    this.timestamp = timestamp;
    this.data = data;
    this.previousHash = previousHash;
    this.nonce = 0;
    this.hash = this.calculateHash();
}

该随机数nonce并没有什么特别的含义，只是为了能改变下生成不同的hash值，以使得hash值满足要求。

相应的hash计算也做修改，即：

calculateHash() {
    return SHA256(this.previousHash + this.timestamp + JSON.stringify(this.data) + this.nonce).toString();
}

解题即挖矿

  如前所述，题目类似：请改变随机数nonce，以保证得出的hash值的前10位全是0。这用代码简单表达如下：
 

this.hash.substring(0, 10) === Array(10 + 1).join("0")

即hash值开头前10位全是0。

而至于到底是前10位还是前5位呢？显然，位数不同，难度不同。保证前10位为0的难度远远大于保证前5位为0。这个位数可以被称为难度系数（difficulty）。而挖矿的过程就是不同尝试nonce，以使得hash值满足条件的过程，即：

mineBlock(difficulty) {
    while (this.hash.substring(0, difficulty) !== Array(difficulty + 1).join("0")) {
        this.nonce++;
        this.hash = this.calculateHash();
    }
    console.log("Block mined, nonce: " + this.nonce + ", hash: " + this.hash);
}

简单起见，可以把difficulty作为区块链的固定参数（注：事实上，在比特币中difficulty是动态调整的，这样来保证出块时间大致是10分钟），如：

constructor() {
    this.chain = [this.createGenesisBlock()];
    this.difficulty = 2;
}

而添加区块的过程，不再是简单直接的add，而变成了挖矿的过程，即：

addBlock(newBlock) {
    newBlock.previousHash = this.getLatestBlock().hash;
    newBlock.mineBlock(this.difficulty);
    this.chain.push(newBlock);
}

只有符合要求的区块才能被添加。

Just run it

跑起来试试，即：

let simpleChain = new BlockChain();
console.log("Mining block 1...");
simpleChain.addBlock(new Block("2018-11-11 00:00:01", {amount: 10}));
console.log("Mining block 2...");
simpleChain.addBlock(new Block("2018-11-11 00:00:02", {amount: 20}));


console.log(JSON.stringify(simpleChain, null, 4));

会发现，整个世界慢了下来，出块明显没有之前快速了，结果如下：

ali-186590cc4a7f:simple-chain shanyao$ node main_2.js 
Mining block 1...
Block mined, nonce: 464064, hash: 0000e7e1aae4fae9d245f8d4b8ce030ffe13270218c362511db6840a824a1cdb
Mining block 2...
Block mined, nonce: 4305, hash: 000047b449537483d7f2861a12b53a59c971d3a928b2c0110a5945bff1a82616
{
    "chain": [
        {
            "timestamp": 0,
            "data": "2018-11-11 00:00:00",
            "previousHash": "Genesis block of simple chain",
            "nonce": 0,
            "hash": "8a7b66d194b1b0b795b0c45b3f11b60e8aa97d3668c831f39ec3343c83ae41c0"
        },
        {
            "timestamp": "2018-11-11 00:00:01",
            "data": {
                "amount": 10
            },
            "previousHash": "8a7b66d194b1b0b795b0c45b3f11b60e8aa97d3668c831f39ec3343c83ae41c0",
            "nonce": 464064,
            "hash": "0000e7e1aae4fae9d245f8d4b8ce030ffe13270218c362511db6840a824a1cdb"
        },
        {
            "timestamp": "2018-11-11 00:00:02",
            "data": {
                "amount": 20
            },
            "previousHash": "0000e7e1aae4fae9d245f8d4b8ce030ffe13270218c362511db6840a824a1cdb",
            "nonce": 4305,
            "hash": "000047b449537483d7f2861a12b53a59c971d3a928b2c0110a5945bff1a82616"
        }
    ],
    "difficulty": 4
}

显然，这里difficulty为4，所得到的区块hash开头为4个0。

POW的思想

  是的，这就是整个proof-of-work的思想。看似很笨很傻的思想，事实上已经被证明，足够的有效、足够的安全。比特币的pow在完全无人主导的情况下，协调了数百万台机器的一致性，历经10年没有出现过一次错误，这不能不说是个伟大的奇迹。事实上，这个最简单的思想背后蕴藏着更深刻的思想，pow的本质是一个cpu投一票（one-cpu-one-vote），即请用你的cpu（算力）来表达你的看法和意见。为什么是CPU，而不是one-ip-one-vote？因为IP太廉价、造假成本太低，你很容易虚拟出大量ip。之所以选择CPU，是因为在当时（2008年）看来，CPU资源是相当昂贵的资源，以此来保证挖矿的难度和公平性（这部分在比特币白皮书上中本聪已经说的非常清楚了
  https://bitcoin.org/bitcoin.pdf）。当然，中本聪可能当时没有想到ASIC等特定算法芯片的出现已经让普通的CPU挖矿变得越来越难，这里篇幅有限不做扩展。
 

  因此POW的本质是什么？本质是提供了一种锚定。将虚拟世界的比特币与现实物理世界的CPU在某种程度上做了锚定，用现实物理世界的昂贵资源来保证比特币的安全性。有人说比特币挖矿太费电，完全是浪费。这其实是一种偏见，换一个角度讲，比特币可能是这个世界上最廉价的货币体系了。毕竟，美元的发行经历了流血与战争，背后还有巨大的昂贵的国家机器、航空母舰在做后盾。而比特币，只是消耗了一些算力、一些电费，并且这种消耗并非是完全无意义的，算力越大整个比特币体系也会越安全。
 

  实际上，共识机制除了POW之外，比较常见的还有DPOS(delegate-proof-of-stake）等，甚至在联盟链中还有pfbt（Practical Byzantine Fault Tolerance）、raft等，这里不做扩展。
 

挖矿回报——利益驱动让区块链走得更远

   如前所述的区块链过于简单，有如下大问题：
  
     每个区块只包含一次交易。这样会导致成本交易成本很高，事实上真实的区块链，每个区块会包含多笔交易，多笔交易会被同时打包到一个区块中。
    
     挖矿没有回报。如果挖矿没有回报，这个世界上谁会买矿机、耗电费为你的交易做校验、打包呢？世界需要雷锋，但世界的运转不能依靠雷锋，需要依靠的是实实在在的利益诱惑。合适的制度设计和激励制度是区块链稳健的根本。其实，在很多POW的加密货币中，挖矿是加密货币发行的唯一方式。比如比特币总共只有2100万个，只能通过挖矿不断挖出来，才能进入二级市场流通。
    
   下面就会着重解决这两点。

定义Transaction

   一个Transaction最基本的信息应包含：从谁转到了谁，转了多少钱，即：
  

   class Transaction {
    constructor(fromAddress, toAddress, amount) {
        this.fromAddress = fromAddress;
        this.toAddress = toAddress;
        this.amount = amount;
    }
}
  

   而每个block应包含多个Transactions，即把之前的data改为transactions：
  

   class Block {
    constructor(timestamp, transactions, previousHash = '') {
        this.timestamp = timestamp;
        this.transactions = transactions;
        this.previousHash = previousHash;
        this.nonce = 0;
        this.hash = this.calculateHash();
    }
    ....
}
  

   而blockchain的数据结构也需要做相应升级，需要增加待处理transactions和每次挖矿报酬额，即：
  

   class BlockChain {
    constructor() {
        this.chain = [this.createGenesisBlock()];
        this.difficulty = 3;
        this.pendingTransactions = [];
        this.miningReward = 100;
    }
    ....
}
  

   请注意这种结构关系：
  

     1个Chain包含多个Block；
    

     1个Block包含多个Transaction；
    

挖矿

   相应地，前面的addBlock方法应该被升级为minePendingTransactions，与之前相比的最大不同在于：
  

     新加的不是单纯的一个区块，而是包含了所有待处理交易信息的区块。（这里简单起见，把所有pendingTranactions都打包了一个区块中，真实场景并非如此，如比特币的原始区块大小只有1M，装不下的就要等待下一个区块打包了；另外矿工实际上通常是谁付费高就优先处理谁的交易）
    

     为矿工付费。一般而言，矿工挖出当前区块之后，会生成一批向矿工地址转账的交易，等待下个区块打包的时候转账。
    

   如下：
  

   //传入矿工地址
minePendingTransactions(miningRewardAddress) {
    //将所有待处理交易一起打包到同一个区块
    let block = new Block(Date.now(), this.pendingTransactions);
    //挖矿，即不断尝试nonce，以使得hash值满足要求
    block.mineBlock(this.difficulty);

    console.log('Block successfully mined!');
    this.chain.push(block);
    
    //将矿工费交易放入到pendingTransactions，待下次处理；矿工费交易的特点是来源账号为空；
    this.pendingTransactions = [
        new Transaction(null, miningRewardAddress, this.miningReward)
    ];
}
//创建交易，即将交易放入待处理交易池
createTransaction(transaction) {
    this.pendingTransactions.push(transaction);
}
  

查询余额

既然有了转账，就自然会有查询某个账户余额的需求。不过在区块链中可能并不存在真的账户，常见的有比特币的UTXO模型和以太坊的账户余额模型。显然，在我们这里，也并不真的存在所谓的账户。这里的区块链交易只记录了从谁转到谁，转了多少钱，并没有记录哪个账户现在有多少钱。怎么才能知道某个账户的余额呢？最笨的方法就是遍历区块链所有的交易信息，根据from/to/amount来推算出某个账户的余额，即：

getBalanceOfAddress(address) {
    let balance = 0;
    for (const block of this.chain) {
        for (const transaction of block.transactions) {
            //账户转出，余额减少
            if (transaction.fromAddress === address) {
                balance -= transaction.amount;
            }
            //账户转入，余额增加
            if (transaction.toAddress === address) {
                balance += transaction.amount;
            }
        }
    }
    return balance;

Just run it

   跑起来看看效果，转账真的成功了吗？矿工收到矿工费了吗？即：
  

   let simpleCoin = new BlockChain();
//首先创建两笔交易，address1先向address2转账100，address2又向address1转账60。
simpleCoin.createTransaction(new Transaction('address1', 'address2', 100));
simpleCoin.createTransaction(new Transaction('address2', 'address1', 60));

console.log('starting the miner...');
simpleCoin.minePendingTransactions('worker1-address');
//显然如果成功，address2应该有40。
console.log('Balance of address2 is: ', simpleCoin.getBalanceOfAddress('address2'));
//矿工账户应该有多少钱呢？按说应该是矿工费100
console.log('Balance of miner is: ', simpleCoin.getBalanceOfAddress('worker1-address'));

//再创建一笔交易，address2又向address1转账10
simpleCoin.createTransaction(new Transaction('address2', 'address1', 10));

console.log('starting the miner again...');
simpleCoin.minePendingTransactions('worker1-address');
//显然如果成功，address2应该还剩30
console.log('Balance of address2 is: ', simpleCoin.getBalanceOfAddress('address2'));
//此时矿工费应该多少呢？处理两个区块，应该有200吧？
console.log('Balance of miner is: ', simpleCoin.getBalanceOfAddress('worker1-address'));
  

   结果如下：
  

   ali-186590cc4a7f:simple-chain shanyao$ node main_3.js 
starting the miner...
Block mined, nonce: 2121, hash: 000cd629157ee59494dfc08329d4cf265180c26010935993171b6881f9bae578
Block successfully mined!
Balance of address2 is:  40
Balance of miner is:  0
starting the miner again...
Block mined, nonce: 1196, hash: 000d5f8278ea9bf4f30c9cc05b4cc36aab8831dc5860e42c775360eb85bc238e
Block successfully mined!
Balance of address2 is:  30
Balance of miner is:  100
  

   可见，address2的余额符合预期；唯一稍特别的是旷工余额，为什么成功打包了，旷工余额还是0，没收到打包费呢？因为矿工费转账放入到了下一个区块，只有下一个区块被成功打包，前一个区块的旷工才能收到矿工费。
  

交易签名与验证

   如前所述，似乎谁都可以发起交易，比如我想发起一笔从中本聪账户到我的账户交易，转账100个。是否可行呢？在前面的模型中，确实似乎谁都可以发起交易。事实上，这当然不可能是真的。截止目前的模型，还缺少重要一环，即必须对交易进行签名，以保证：你只能从你的自己的账户转出钱，你没有别人账户的密码就不可能操作别人的账户。
  

无法找回的密码

   密码其实是现实世界的概念，比如银行卡密码、淘宝登录密码、自动门禁的密码，你必须妥善保管，一旦被人知道了财产可能损失；当然，你如果怀疑密码被盗，可以赶紧改下密码；如果真的记不起密码，还可以带上身份证去银行修改密码。
  
   然而，在区块链的世界中，不存在改密码、找回密码的说法。更重要的是，在区块链的世界中没有身份证，密码本身就是身份证。

非对称加密

区块链世界的唯一密码就是私钥。私钥是如何而来的？是通过非对称加密生成的，非对称的意思就是加密和解密使用不同的密钥。听起来很复杂，其实思想很简单，如下：

非对称加密算法会生成一对密钥，一个是公开密钥publicKey，一个是私有密钥privateKey。二者可以互相加密解密，即公钥加密的，只有对应私钥才能解开；私钥加密的，只有对应公钥才能打开。
无法从公钥推导出私钥；但可以从私钥推导出公钥。（绝大多数对RSA的实现，都遵循pkcs的标准，即私钥能推出公钥，但公钥不能推出私钥）
公钥用于加密，私钥用于解密：用公钥加密的数据，只有用相应的私钥才能解密。公钥类似邮箱地址，所有人都知道，谁都可以往里面寄信；但只有邮箱的主人才拥有密钥才能打开。
私钥用于签名，公钥用于验证：东邪收到西毒的来信，但怎么确定这信真的是西毒写的呢？西毒把信用自己的密钥签名（其实就是加密），东邪收到信息之后，拿公开的西毒的公钥去试试能否解密，若能解密则确信是西毒的来信。

让我们简单地生成一对公钥私钥来看看，即：

const EC = require('elliptic').ec;
const ec = new EC('secp256k1');

const key = ec.genKeyPair();
const publicKey = key.getPublic('hex');
const privateKey = key.getPrivate('hex');

console.log('Public key', publicKey);
console.log('Private key', privateKey);

结果：

Public key 04f1aa4d934e7f2035a6c2a2ebc9daf0e9ca7d13855c2a0fb8696ab8763e5ee263c803dfa7ac5ae23b25fb98151c99f91c55e89586717965758e6663772ebccd1b
Private key 1c258d67b50bda9377c1badddd33bc815eeac8fcb9aee5d097ad6cedc3d2310c

这个privateKey就是你的唯一密码，有32字节。而publicKey看起来似乎更长。但是平时看到的比特币地址似乎很短啊？是的，这里的publicKey有65字节，而开头1个字节是固定的0x04，除此之外的前32字节是椭圆曲线的X坐标，后32字节是椭圆曲线的Y坐标。比特币地址之所以更短，是因为又经过了SHA256加密、RIPEMD160加密和BASE58编码等等一系列的转化，最后生成了类似“1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa”这样的base58地址，这里简单起见不做扩展。通常而言，publicKey就是你的账户地址，只是格式的不同，可以进行可逆转化。

签名你的交易

   首先，我们需要用自己的私钥，对发起的交易进行签名，以表明交易确实是由本人发起的，如：
  

   class Transaction {
    //计算hash，为了做签名，因为不是直接对原始信息进行签名，而是对hash值签名。
    calculateHash() {
        return SHA256(this.fromAddress + this.toAddress + this.amount).toString();
    }

    //传入私钥
    signTransaction(signingKey) {
        //校验来源账户是否是本人的地址，即来源地址是否是该私钥对应的公钥
        if (signingKey.getPublic('hex') !== this.fromAddress) {
            throw new Error('You cannot sign transactions for other wallets!')
        }
        const txHash = this.calculateHash();
        //用私钥对交易hash进行签名
        const sig = signingKey.sign(txHash, 'base64');
        //将签名转成der格式
        this.signature = sig.toDER('hex');
        console.log("signature: "+this.signature)
    }
    ...
}
  

验证交易

   随后，其他人收到该交易信息时，需要验证交易是否有效，即用来源账户的公钥来验证这笔交易的签名是否正确、是否真的是来自于fromAddress，如下：
  

   class Transaction {
    isValid() {
        //矿工费交易fromAddress为空，不做校验
        if (this.fromAddress === null) return true;
        //判断签名是否存在
        if (!this.signature || this.signature.length === 0) {
            throw new Error('No signature in this transaction');
        }
        //对fromAddress转码，得到公钥（这一过程是可逆的，只是格式转化）
        const publicKey = ec.keyFromPublic(this.fromAddress, 'hex');
        //用公钥验证签名是否正确，即交易是否真的从fromAddress发起的
        return publicKey.verify(this.calculateHash(), this.signature);
    }
    ...
}
  

   上面对单个交易的有效性进行了验证，而一个区块包含多笔交易，所以也需要增加对区块内所有交易验证的方法，如：
  

   class Block {
    hasValidTransactions() {
        //遍历区块内所有交易，逐一验证
        for (const tx of this.transactions) {
            if (!tx.isValid()) {
                return false;
            }
        }
        return true;
    }
    ...
}
  

   相应的，createTransaction也升级为addTransaction，即不再直接创建交易，而是要对已签名交易进行验证，有效的交易才提交。如：
  

   class BlockChain {
    addTransaction(transaction) {
        if (!transaction.fromAddress || !transaction.toAddress) {
            throw new Error('Transaction must include from and to address');
        }
        //验证交易是否有效，有效的才能提交到交易池中
        if (!transaction.isValid()) {
            throw new Error('Cannot add invalid transaction to the chain');
        }
        this.pendingTransactions.push(transaction);
    }
    ...
}
  

   相应的blockchain的isChainValid方法也应升级，加入区块内所有交易的验证，即：
  

   class BlockChain {
    isChainValid() {
        for (let i = 1; i < this.chain.length; i++) {
            const currentBlock = this.chain[i];
            const previousBlock = this.chain[i - 1];
            //校验区块内的所有交易是否有效
            if (!currentBlock.hasValidTransactions()) {
                return false;
            }
            if (currentBlock.hash !== currentBlock.calculateHash()) {
                console.error("hash not equal: " + JSON.stringify(currentBlock));
                return false;
            }
            if (currentBlock.previousHash !== previousBlock.calculateHash()) {
                console.error("previous hash not right: " + JSON.stringify(currentBlock));
                return false;
            }
        }
        return true;
    }
    ...
}
  

Just run it

   跑起来试试，如下：
  

   const {BlockChain, Transaction} = require('./blockchain');
const EC = require('elliptic').ec;
const ec = new EC('secp256k1');
//用工具生成一对私钥和公钥
const myPrivateKey = '1c258d67b50bda9377c1badddd33bc815eeac8fcb9aee5d097ad6cedc3d2310c';
const myPublicKey = '04f1aa4d934e7f2035a6c2a2ebc9daf0e9ca7d13855c2a0fb8696ab8763e5ee263c803dfa7ac5ae23b25fb98151c99f91c55e89586717965758e6663772ebccd1b';

const myKey = ec.keyFromPrivate(myPrivateKey);
//从私钥推导出公钥
const myWalletAddress = myKey.getPublic('hex');
//输出看下，确实从私钥得到了公钥
console.log("is the myWalletAddress from privateKey equals to publicKey?", myWalletAddress === myPublicKey);

let simpleCoin = new BlockChain();

const trumpPublicKey = '047058e794dcd7d9fb0a256349a5e2d4d724b50ab8cfba2258e1759e5bd4c81bb6ac1b0490518287ac48f0f10a58dc00cda03ffd6d03d67158f8923847c8ad4e7d';
//发起交易，从自己账户向trump转账60
const tx1 = new Transaction(myWalletAddress, trumpPublicKey, 60);
//用私钥签名
tx1.signTransaction(myKey);
//提交交易
simpleCoin.addTransaction(tx1);

console.log('starting the miner...');
simpleCoin.minePendingTransactions(myWalletAddress);
//若转账成功，trump账户余额应是60
console.log('Balance of trump is: ', simpleCoin.getBalanceOfAddress(trumpPublicKey));

//发起交易，从trump账户向你的账户转回20
const tx2 = new Transaction(trumpPublicKey, myWalletAddress, 20);
//仍用你的私钥签名，这里会报错，你并不知道trump的密钥，无法操作其账户，即你的密钥打不开trump的账户；
tx2.signTransaction(myKey);
simpleCoin.minePendingTransactions(myWalletAddress);
console.log('Balance of trump is: ', simpleCoin.getBalanceOfAddress(trumpPublicKey));
  

   结果如下：
  

   ali-186590cc4a7f:simple-chain shanyao$ node main.js 
is the myWalletAddress from privateKey equals to publicKey? true
signature: 3045022100b87a9199c2b3fa31ac4092b27a41a616d99df884732dfd65972dc9eacd12da7702201f7957ef25d42c17cb2f6fb2888e6a0d5c521225d9b8851ba2d228f96d878f85
starting the miner...
Block mined, nonce: 15812, hash: 00081837c2ae46a1310a0873f5e3d6a1b14b072e3d32a538748fac71e0bfd91e
Block successfully mined!
Balance of trump is:  60
/Users/shanyao/front/simple-chain/blockchain.js:22
            throw new Error('You cannot sign transactions for other wallets!')
  

   显然，第一次操作并签名的是自己的账户，有私钥能成功；第二次操作的是别人的账户，私钥不对，无法提交转账。私钥就是区块链世界的唯一密码、唯一通行证，只有拥有私钥的人才能拥有对应的资产，这也许就是真正的私有财产神圣不可侵犯。
  

总结

   如果看到这里，是不是觉得区块链很简单？是的，没有想象中复杂，但其实也没那么简单。事实上，区块链真正核心的共识机制（分布式协调一致性）以及去中心化治理，本文并未涉及。本文只是简单介绍了区块链的基本结构、基本概念和大致交易过程，帮忙大家初步认识区块链，解开区块链神秘的面纱。而区块链本身是一个宏大的主题，还需要更多的研究，更多的思考和探索。
  

初识区块链——用JS构建你自己的区块链

前言

认识区块链

Block的数据结构

BlockChain的数据结构

创世区块

添加区块

校验区块链

Just run it

篡改下试试

再篡改下试试

是真的无法篡改吗

工作量证明（Proof-of-Work）让区块链更安全

出一道题

为区块增加随机数nonce

解题即挖矿

Just run it

POW的思想

挖矿回报——利益驱动让区块链走得更远

定义Transaction

挖矿

查询余额

Just run it

交易签名与验证

无法找回的密码

非对称加密

签名你的交易

验证交易

Just run it

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景