AI 助理
备案控制台
开发者社区 安全 文章 正文

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

2018-12-03 2456
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
密钥管理服务KMS，1000个密钥，100个凭据，1个月
简介： 前言 区块链太复杂，那我们就讲点简单的。用JS来构建你自己的区块链系统，寥寥几行代码就可以说明区块链的底层数据结构、POW挖矿思想和交易过程等。当然了，真实的场景远远远比这复杂。本文的目的仅限于让大家初步了解、初步认识区块链。

前言

区块链太复杂，那我们就讲点简单的。用JS来构建你自己的区块链系统，寥寥几行代码就可以说明区块链的底层数据结构、POW挖矿思想和交易过程等。当然了，真实的场景远远远比这复杂。本文的目的仅限于让大家初步了解、初步认识区块链。
感谢原作者，本文在原视频基础上做了修改补充，并加入了个人理解。

认识区块链

区块链顾名思义是由区块连接而成的链，因此最基本的数据结构是Block。每个Block都含有timestamp、data、hash、previousHash等信息。其中data用来存储数据，previousHash是前一个区块的hash值。示意如下：
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!')
显然，第一次操作并签名的是自己的账户，有私钥能成功；第二次操作的是别人的账户，私钥不对，无法提交转账。私钥就是区块链世界的唯一密码、唯一通行证，只有拥有私钥的人才能拥有对应的资产，这也许就是真正的私有财产神圣不可侵犯。

总结

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

文章标签：
密钥管理服务
区块链
数据安全/隐私保护
JavaScript
安全
关键词：
JavaScript构建
区块链构建
JavaScript区块链
区块链js
区块链服务构建
WeiKuo
目录
相关文章
想飞的雪糕
|
2月前
|
前端开发 机器人 API
前端大模型入门（一）：用 js+langchain 构建基于 LLM 的应用
本文介绍了大语言模型（LLM）的HTTP API流式调用机制及其在前端的实现方法。通过流式调用，服务器可以逐步发送生成的文本内容，前端则实时处理并展示这些数据块，从而提升用户体验和实时性。文章详细讲解了如何使用`fetch`发起流式请求、处理响应流数据、逐步更新界面、处理中断和错误，以及优化用户交互。流式调用特别适用于聊天机器人、搜索建议等应用场景，能够显著减少用户的等待时间，增强交互性。
想飞的雪糕
440 2
请看我回答~
|
20天前
|
Web App开发 JavaScript 前端开发
深入浅出Node.js：从零开始构建后端服务
【10月更文挑战第42天】在数字时代的浪潮中，掌握一门后端技术对于开发者来说至关重要。Node.js，作为一种基于Chrome V8引擎的JavaScript运行环境，允许开发者使用JavaScript编写服务器端代码，极大地拓宽了前端开发者的技能边界。本文将从Node.js的基础概念讲起，逐步引导读者理解其事件驱动、非阻塞I/O模型的核心原理，并指导如何在实战中应用这些知识构建高效、可扩展的后端服务。通过深入浅出的方式，我们将一起探索Node.js的魅力和潜力，解锁更多可能。
请看我回答~
38 6
Star时光
|
2月前
|
存储 JavaScript 前端开发
使用JavaScript构建动态交互式网页：从基础到实践
【10月更文挑战第12天】使用JavaScript构建动态交互式网页：从基础到实践
Star时光
118 1
游客sjjs6jgz4gp7m1
|
1月前
|
JavaScript 中间件 关系型数据库
构建高效的后端服务：Node.js 与 Express 的实践指南
在后端开发领域，Node.js 与 Express 的组合因其轻量级和高效性而广受欢迎。本文将深入探讨如何利用这一组合构建高性能的后端服务。我们将从 Node.js 的事件驱动和非阻塞 I/O 模型出发，解释其如何优化网络请求处理。接着，通过 Express 框架的简洁 API，展示如何快速搭建 RESTful API。文章还将涉及中间件的使用，以及如何结合 MySQL 数据库进行数据操作。最后，我们将讨论性能优化技巧，包括异步编程模式和缓存策略，以确保服务的稳定性和扩展性。
游客sjjs6jgz4gp7m1
51 17
我不是游客20240119
|
23天前
|
JSON JavaScript API
深入浅出Node.js：从零开始构建RESTful API
【10月更文挑战第39天】 在数字化时代的浪潮中，API（应用程序编程接口）已成为连接不同软件应用的桥梁。本文将带领读者从零基础出发，逐步深入Node.js的世界，最终实现一个功能完备的RESTful API。通过实践，我们将探索如何利用Node.js的异步特性和强大的生态系统来构建高效、可扩展的服务。准备好迎接代码和概念的碰撞，一起解锁后端开发的新篇章。
我不是游客20240119
29 1
技术混子
|
1月前
|
资源调度 前端开发 数据可视化
构建高效的数据可视化仪表板：D3.js与React的融合之道
【10月更文挑战第25天】在数据驱动的时代，将复杂的数据集转换为直观、互动式的可视化表示已成为一项至关重要的技能。本文深入探讨了如何结合D3.js的强大可视化功能和React框架的响应式特性来构建高效、动态的数据可视化仪表板。文章首先介绍了D3.js和React的基础知识，然后通过一个实际的项目案例，详细阐述了如何将两者结合使用，并提供了实用的代码示例。无论你是数据科学家、前端开发者还是可视化爱好者，这篇文章都将为你提供宝贵的洞见和实用技能。
技术混子
57 5
龙大吉
|
1月前
|
JavaScript 前端开发 持续交付
构建现代Web应用：Vue.js与Node.js的完美结合
【10月更文挑战第22天】随着互联网技术的快速发展，Web应用已经成为了人们日常生活和工作的重要组成部分。前端技术和后端技术的不断创新，为Web应用的构建提供了更多可能。在本篇文章中，我们将探讨Vue.js和Node.js这两大热门技术如何完美结合，构建现代Web应用。
龙大吉
35 4
mrq4nk6ni2neg
|
2月前
|
Web App开发 JavaScript 中间件
构建高效后端服务：Node.js与Express框架的完美结合
【10月更文挑战第21天】本文将引导你走进Node.js和Express框架的世界，探索它们如何共同打造一个高效、可扩展的后端服务。通过深入浅出的解释和实际代码示例，我们将一起理解这一组合的魅力所在，并学习如何利用它们来构建现代Web应用。
mrq4nk6ni2neg
56 1
历年考试不作弊
|
27天前
|
JavaScript 前端开发 NoSQL
深入浅出：使用Node.js构建RESTful API
【10月更文挑战第35天】在数字时代的浪潮中，后端技术如同海洋中稳固的灯塔，为前端应用提供数据和逻辑支撑。本文旨在通过浅显易懂的方式，带领读者了解如何利用Node.js这一强大的后端平台，搭建一个高效、可靠的RESTful API。我们将从基础概念入手，逐步深入到代码实践，最终实现一个简单的API示例。这不仅是对技术的探索，也是对知识传递方式的一次创新尝试。让我们一起启航，探索Node.js的奥秘，解锁后端开发的无限可能。
历年考试不作弊
22 0
G0518
|
2月前
|
存储 JavaScript 前端开发
深入探索 Vue.js：构建现代 Web 应用的利器
【10月更文挑战第11天】深入探索 Vue.js：构建现代 Web 应用的利器
G0518
24 1

热门文章

最新文章

  • 1
    关于区块链，你绝不能忽视的4个安全问题和5招应对方法！
  • 2
    曾鸣：区块链是否要“去中心化”？ | 阿里内部干货
  • 3
    当人工智能遇上区块链，会发生什么？
  • 4
    300行Kotlin代码实现的区块链
  • 5
    市场调研：2023年区块链市场规模有望突破160亿美元
  • 6
    区块链智能资产的“硬链接”思考
  • 7
    一边转载一边学习区块链
  • 8
    Hyperledger Fabric 2.x Java区块链应用
  • 9
    塞拉利昂利用区块链追踪选举结果，区块链史上首次参与到了政府选举中
  • 10
    微软携手美国银行发力区块链
  • 1
    使用Vue.js构建交互式前端的技术探索
    87
  • 2
    使用Node.js构建实时聊天应用的技术指南
    121
  • 3
    深入理解JavaScript中的事件循环机制
    85
  • 4
    【MongoDB 专栏】MongoDB 的 JavaScript 引擎与脚本执行
    114
  • 5
    JavaScript 数组方法概览
    37
  • 6
    在JavaScript中，函数原型（Function Prototype）是一个特殊的对象
    64
  • 7
    JavaScript 的数组方法 map()、filter() 和 reduce() 提供了函数式编程处理元素的方式
    47
  • 8
    JavaScript 提供了多种方法来操作 DOM（文档对象模型）
    48
  • 9
    JavaScript的垃圾回收机制通过标记-清除算法自动管理内存
    58
  • 10
    JavaScript 的垃圾回收机制有一些潜在的缺点
    41

    • 相关课程

    更多
  • JavaScript入门与实战
  • JavaScript 自学手册文档教程

    • 相关电子书

    更多
  • JavaScript异步编程
  • Delivering Javascript to World
  • 编程语言如何演化-以JS的private为例

    • 相关实验场景

    更多
  • Html5和Webpack2：Webpack5打包JS和样式表
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月