基于Java语言构建区块链(二)—— 工作量证明

发布时间:2018年09月27日 价值:20000.00 / 共识:24

原文链接:https://wangwei.one/posts/7890ab7e.html

引言

上一篇 文章中,我们实现了区块链最基本的数据结构模型,添加区块以及和前一个区块连接在一起。但是,我们的实现方式非常简单,而真实的比特币区块链中,每一个区块的添加都是需要经过大量的计算才可以完成,这个过程就是我们熟知的挖矿

工作量证明机制

区块链最关键的一个思想就是,必须进行大量且困难的计算工作才能将交易数据存放到区块链上。这种工作机制才能保证整个区块链数据的安全性和一致性。同时,完成这个计算工作的矿工会得到相应的Token奖励。

这套机制和我们的现实生活非常相似:我们必须努力工作来赚取报酬用以维持我们的生活。在区块链中,网络中的矿工们努力工作来维持区块链网络,为其添加区块,并且获得一定的Token奖励。作为他们工作的成果,一个区块以安全的方式被组合进了区块链中,这样就保证了整个区块链数据库的稳定性。还有一个必须要注意的是,某个矿工完成了计算工作的结果,还必须得到其他所有矿工的认同(证明是正确的),这样才算完成。

这一整套的计算和证明机制,就称为Proof-of-Work(工作量证明)。计算工作是非常非常困难的,因为它需要消耗大量的计算机算力资源,即使是性能非常高的计算机都不能非常快地计算出正确的结果。此外,随着时间的推移,这项计算工作的难度也会随之增加,目的是为了保证每小时6个新区块的出块率。在比特币中,这种工作的目标是找到满足某个特定要求的区块Hash(哈希值)。这个区块哈希值就是工作结果的一个证明。因此,计算工作的目的就是为了寻找到这个证明值。

最后要注意的是,计算出这个特定的Hash(哈希值)是非常困难的,但是别人来验证这个Hash值是否正确的时候,是非常简单的,一下子就能完成。

Hashing

Hash:哈希 | 散列

我们来讨论一下Hashing(哈希),对这一块非常熟悉的朋友可以直接跳过这一段内容。

哈希是一种计算机算法,该算法能够计算出任意大小数据的哈希值,并且这个哈希值的长度是固定的,256bit。这个被计算出来的哈希值能够作为这个数据的唯一代表。哈希算法有几个关键的特性:

  • 不可逆性。不能根据一个哈希值推导出原始数据。所以,哈希不是加密。
  • 唯一性。每个数据有且仅有一个唯一的哈希值。
  • 迥异性。原始数据一丁点的变化都将得到完全不一样的哈希值。

例如:

  1. SHA256("wangwei1") ——> 1e898b7c9adaad86c20139a302ccd5277f81040cab68dc2aecfc684773532652
  2. SHA256("wangwei2") ——> c9cc7417c17318c8aab448cc8ace24c53b6dcf350f5c5fd8e91cbc3b011a179d

哈希算法被广泛用于验证文件的一致性上。比如软件提供商通常会在安装包上附加一个检验码(checksums),当我们下载完一个软件安装包后,可以用哈希函数计算一下这个软件安装包的哈希值,然后再和软件安装包的检验码做个对比,就可以知道下载的安装包是否完整、是否有数据丢失。

在区块链中,哈希值用于保证区块的一致性。每一个区块被用于进行哈希计算的数据,都包含前一个区块链的哈希值,因此任何人想要修改区块的数据几乎是不可能的,他必须要把整个区块链中从创世区块到最新的区块的所有哈希值全部重新计算一遍。

你可以脑补一下这个工作量有多大,按照目前计算机的算力来看,几乎不可能

Hashcash

比特币的工作量证明是使用的是Hashcash算法,一种最初被用于反垃圾邮件的算法,它可以被拆解为以下几步:

  1. 获取某种公开可知的数据data(在邮件案例中,指的是收件人邮件地址;比特币案例中,指的是区块头)
  2. 添加一个计数器counter,初始值设置为0;
  3. 计算 data 与 counter拼接字符串的哈希值;
  4. 检查上一步的哈希值是否满足某个条件,满足则停止计算,不满足则 counter 加1,然后重复第3步和第4步,直到满足这个特定的条件为止。

这是一种粗暴的算法:你改变计数器,计算一个新的哈希值,检查它,增加计数器,计算一个新的哈希值,循环往复,这就是为什么它需要花费大量计算机算力资源的原因所在。

让我们来近距离看一下这个特定的条件指的是什么。在原始的Hashcash算法中,这个特殊的要求指的是计算出来的哈希值的前20bit必须全是零,

在比特币种,这种要求哈希值前面有多少个零打头的要求是随着时间的推移而不断调整的,这是出于设计的目的,尽管在计算机的算力会不断的提升和越来越多的矿工加入这个网络中的情况下,都要保证每10min生产一个区块。

我们演示一下这个算法,

  1. # 计算字符串'I like donuts'的哈希值
  2. SHA256("I like donuts")
  3. ——> f80867f6efd4484c23b0e7184e53fe4af6ab49b97f5293fcd50d5b2bfa73a4d0
  4. # 拼接一个计数器值(ca07ca),再次进行Hash计算
  5. SHA256("I like donutsca07ca")
  6. ——> 0000002f7c1fe31cb82acdc082cfec47620b7e4ab94f2bf9e096c436fc8cee06

这里的ca07ca是计数器值的十六进制,他表示的十进制值为13240266

即,从0开始,总共计算了13240266次,才计算出I like donuts这个数据的Hash值,满足前6位(3字节)全是零。

代码实现

思路:

1)每次区块被添加到区块链之前,先要进行挖矿(Pow)

2)挖矿过程中,产生的 Hash 值,如果小于难度目标值则添加进区块,否则继续挖矿,直到找到正确的Hash为止

3)最后,验证区块Hash是否有效

定义Pow类

  1. /**
  2. * 工作量证明
  3. *
  4. * @author wangwei
  5. * @date 2018/02/04
  6. */
  7. @Data
  8. public class ProofOfWork {
  9. /**
  10. * 难度目标位
  11. */
  12. public static final int TARGET_BITS = 20;
  13. /**
  14. * 区块
  15. */
  16. private Block block;
  17. /**
  18. * 难度目标值
  19. */
  20. private BigInteger target;
  21. private ProofOfWork(Block block, BigInteger target) {
  22. this.block = block;
  23. this.target = target;
  24. }
  25. /**
  26. * 创建新的工作量证明,设定难度目标值
  27. * <p>
  28. * 对1进行移位运算,将1向左移动 (256 - TARGET_BITS) 位,得到我们的难度目标值
  29. *
  30. * @param block
  31. * @return
  32. */
  33. public static ProofOfWork newProofOfWork(Block block) {
  34. BigInteger targetValue = BigInteger.valueOf(1).shiftLeft((256 - TARGET_BITS));
  35. return new ProofOfWork(block, targetValue);
  36. }
  37. }
  • 设定一个难度目标位TARGET_BITS,表示最终挖矿挖出来Hash值,转化为二进制后,与256相比,长度少了多少bit,也即二进制前面有多少bit是零.

    • TARGET_BITS 越大,最终targetValue就越小,要求计算出来的Hash越来越小,也就是挖矿的难度越来越大。
    • 我们这里的TARGET_BITS是固定的,但是在真实的比特币中,难度目标是随着时间的推推,会动态调整的。详见:《精通比特币 (第二版)》第10章
  • 由于数值比较大,这里要使用BitInteger类型。

准备数据

  1. /**
  2. * 准备数据
  3. * <p>
  4. * 注意:在准备区块数据时,一定要从原始数据类型转化为byte[],不能直接从字符串进行转换
  5. * @param nonce
  6. * @return
  7. */
  8. private String prepareData(long nonce) {
  9. byte[] prevBlockHashBytes = {};
  10. if (StringUtils.isNoneBlank(this.getBlock().getPrevBlockHash())) {
  11. prevBlockHashBytes = new BigInteger(this.getBlock().getPrevBlockHash(), 16).toByteArray();
  12. }
  13. return ByteUtils.merge(
  14. prevBlockHashBytes,
  15. this.getBlock().getData().getBytes(),
  16. ByteUtils.toBytes(this.getBlock().getTimeStamp()),
  17. ByteUtils.toBytes(TARGET_BITS),
  18. ByteUtils.toBytes(nonce)
  19. );
  20. }
  • 参与Hash运算的如下几个信息:
    • 前一个区块(父区块)的Hash值;
    • 区块中的交易数据;
    • 区块生成的时间;
    • 难度目标;
    • 用于工作量证明算法的计数器

详见:《精通比特币 (第二版)》第09章

Pow算法

  1. /**
  2. * 运行工作量证明,开始挖矿,找到小于难度目标值的Hash
  3. *
  4. * @return
  5. */
  6. public PowResult run() {
  7. long nonce = 0;
  8. String shaHex = "";
  9. System.out.printf("Mining the block containing:%s \n", this.getBlock().getData());
  10. long startTime = System.currentTimeMillis();
  11. while (nonce < Long.MAX_VALUE) {
  12. String data = this.prepareData(nonce);
  13. shaHex = DigestUtils.sha256Hex(data);
  14. if (new BigInteger(shaHex, 16).compareTo(this.target) == -1) {
  15. System.out.printf("Elapsed Time: %s seconds \n", (float) (System.currentTimeMillis() - startTime) / 1000);
  16. System.out.printf("correct hash Hex: %s \n\n", shaHex);
  17. break;
  18. } else {
  19. nonce++;
  20. }
  21. }
  22. return new PowResult(nonce, shaHex);
  23. }
  • 循环体里面主要以下四步:
    • 准备数据
    • 进行sha256运算
    • 转化为BigInter类型
    • 与target进行比较
  • 最后,返回正确的Hash值以及运算计数器nonce

验证区块Hash有效性

  1. /**
  2. * 验证区块是否有效
  3. *
  4. * @return
  5. */
  6. public boolean validate() {
  7. String data = this.prepareData(this.getBlock().getNonce());
  8. return new BigInteger(DigestUtils.sha256Hex(data), 16).compareTo(this.target) == -1;
  9. }

修改区块添加逻辑

  1. /**
  2. * <p> 创建新区块 </p>
  3. *
  4. * @param previousHash
  5. * @param data
  6. * @return
  7. */
  8. public static Block newBlock(String previousHash, String data) {
  9. Block block = new Block("", previousHash, data, Instant.now().getEpochSecond(), 0);
  10. ProofOfWork pow = ProofOfWork.newProofOfWork(block);
  11. PowResult powResult = pow.run();
  12. block.setHash(powResult.getHash());
  13. block.setNonce(powResult.getNonce());
  14. return block;
  15. }
  • 创建区块
  • 创建Pow算法对象
  • 执行Pow算法
  • 保存返回的Hash以及运算计数器

测试运行

  1. /**
  2. * 测试
  3. *
  4. * @author wangwei
  5. * @date 2018/02/05
  6. */
  7. public class BlockchainTest {
  8. public static void main(String[] args) {
  9. Blockchain blockchain = Blockchain.newBlockchain();
  10. blockchain.addBlock("Send 1 BTC to Ivan");
  11. blockchain.addBlock("Send 2 more BTC to Ivan");
  12. for (Block block : blockchain.getBlockList()) {
  13. System.out.println("Prev.hash: " + block.getPrevBlockHash());
  14. System.out.println("Data: " + block.getData());
  15. System.out.println("Hash: " + block.getHash());
  16. System.out.println("Nonce: " + block.getNonce());
  17. ProofOfWork pow = ProofOfWork.newProofOfWork(block);
  18. System.out.println("Pow valid: " + pow.validate() + "\n");
  19. }
  20. }
  21. }
  22. /**
  23. * 设定TARGET_BITS = 20,得到如下结果:
  24. */
  25. Mining the block containingGenesis Block
  26. Elapsed Time: 2.118 seconds
  27. correct hash Hex: 00000828ee8289ef6381f297585ef8c952fde93fc2b673ff7cc655f699bb2442
  28. Mining the block containingSend 1 BTC to Ivan
  29. Elapsed Time: 1.069 seconds
  30. correct hash Hex: 00000a38c0d7f2ebbd20773e93770298aa8bc0cc6d85fca8756fe0646ae7fea5
  31. Mining the block containingSend 2 more BTC to Ivan
  32. Elapsed Time: 4.258 seconds
  33. correct hash Hex: 00000777f93efe91d9aabcba14ab3d8ab8e0255b89818cdb9b93cfa844ad0c7f
  34. Prev.hash:
  35. Data: Genesis Block
  36. Hash: 00000828ee8289ef6381f297585ef8c952fde93fc2b673ff7cc655f699bb2442
  37. Nonce: 522163
  38. Pow valid: true
  39. Prev.hash: 00000828ee8289ef6381f297585ef8c952fde93fc2b673ff7cc655f699bb2442
  40. Data: Send 1 BTC to Ivan
  41. Hash: 00000a38c0d7f2ebbd20773e93770298aa8bc0cc6d85fca8756fe0646ae7fea5
  42. Nonce: 474758
  43. Pow valid: true
  44. Prev.hash: 00000a38c0d7f2ebbd20773e93770298aa8bc0cc6d85fca8756fe0646ae7fea5
  45. Data: Send 2 more BTC to Ivan
  46. Hash: 00000777f93efe91d9aabcba14ab3d8ab8e0255b89818cdb9b93cfa844ad0c7f
  47. Nonce: 1853839
  48. Pow valid: true

总结

我们正在一步一步接近真实的区块链架构,本篇我们实现了挖矿机制,但是我们还有很多关键性的功能没有实现:区块链数据库的持久性、钱包、地址、交易、共识机制,这些我们后面一步一步来实现

资料

  • 分享 收藏
0 条评论
  • 这篇文章暂无评论,赶紧评论一下吧~