目录

1 区块链和人工智能

2 区块链的相关概念及流程

2.1 官方定义

2.2 普通区块&创世区块

2.3  区块的工作流程 

3 区块链Python代码实现 

4 致谢 

1 区块链和人工智能

人工智能和区块链诞生至今已经有了十几年，当这些技术出现时，人们都说他们会改变世界，但至今为止，这两项技术对现实的影响依然有限。从技术上看人工智能的原理其实是从大量数据中寻找规律或模式，但区块链的技术原理是什么呢？在我看来区块链的原理一直处于云里雾里，有很多近乎玄学的解释将其笼罩，有人从经济学解释，有人从社会学解释，从”人文“角度解释的区块链总是过于夸大其词，这些说法中往往又包含不良用心。

区块链的设计思想非常伟大，它集合了很多智慧的结晶，例如加密算法，分布式算法，心理学，经济学等，由于它跨越领域太多，这也是它特别“玄学”的原因

其实区块链和人工智能一样，从技术的角度看去，他们都有着极为美妙的设计思想，这些设计的美妙就像唐诗宋词，就像毕加索的话，如果我们没有去欣赏它的美，那岂不可惜。相比于人工智能，我认为区块链在技术上更容易被普通人触碰，因为前者需要大量的数据和算力，而后者只要我们掌握其技术原理就能参与其中，不需要太高的硬件门槛。

2 区块链的相关概念及流程

2.1 官方定义

区块链的官方定义是：一个分布式账本，一种通过去中心化、去信任的方式集体维护一个可靠数据库的技术方案。那么对于圈外人该如何理解呢？以下我会详细描述一个区块链的产生过程和实现意义，从而给大家构建出一个清晰的区块链概念。

在大势所趋——区块链这篇文章中我讲解了一些基本概念。

2.2 普通区块&创世区块

我们以btc为例：“区块链”，顾名思义，就是由一个个区块依次连接起来组成的链条，可以类比为一条无限长度的直线铁链，每个铁环就是一个区块。那么区块的内容应该是什么呢？区块狭义上是有两种的，一个是普通区块，一个就是创世区块。创世区块就是一项区块链项目中的第一个区块，由于个人水平有限，对创世区块没有做过详细研究，但是根据我的了解，创世区块应该是具备与普通区块相似结构的，但会肯定会加入一些创始人想说的东西，并且在有些项目中可能会多一条记录，就是coin的发行量，例如swtc的6000亿数目就是写在创世区块之中的，一旦发行，无法修改。

那么，一个普通区块中到底有什么？

(1)index：就是从0-n依次产生的数字，可以称之为链高度。

(2)hash：一个长度为256位随机数，是这个区块的唯一编号。

(3)previous hash：上一个区块的hash，一个普通区块有且仅有一个previous hash，这就是区块链之所以称为链的原因，就是这么一环套一环链接而成的。

(4)tempstamp：用于记录该区块诞生的时间。

(5)difficulty：直观体现创造该区块的难度。

(6)nonce：随机数，用于产生下一个区块。

上述的都存在区块头中。

(7)data：存储的交易记录。只有这个存在区块体中。

2.3  区块的工作流程 

(1)如果A要和B达成一笔交易，比如A转给B一个btc，B给A打10w的RMB。A首先将自己的btc来源信息、交易人等发送给B，同时还要拷贝一份发到全网。什么？这样还有隐私可言吗？当然，聪明的中本聪当然不会犯这么低级的错误。在区块链中，每个交易个体（也可以理解为每个网络节点）都会有一对公钥和私钥，公钥相当于一个“收款地址”，而私钥是一个表明自己身份的256位的数字，目前一般是用sha265来生成的，这样，别人并不知道交易的双方是谁。发送报文时，发送方用一个哈希函数从报文文本中生成报文摘要，然后用自己的私钥对摘要进行加密，加密后的摘要将作为报文的数字签名和报文一起发送给接收方，接收方首先用与发送方一样的哈希函数从接收到的原始报文中计算出报文摘要，接着再用发送方的公钥来对报文附加的数字签名进行解密，如果这两个摘要相同、那么接收方就能确认该数字签名是发送方的。

(2)那么此时，这笔交易是否就完成了呢？如果这就算完成了，那跟A直接用包裹装10w现金快递给B有什么区别呢？此时，全网的矿工都会得到这个交易记录，那么全网的矿工都会为了若干奖励开始创建区块的工作，矿工会利用hash函数生成一个256位的唯一编号赋予这个区块，但是这个编号并不是简简单单随便生成的。编号是根据区块的具体内容如交易内容、nonce等唯一确定的，换句话说，两块内容相同的区块所对应的编号一定是唯一的。可是你会问：这又怎么了？并不难啊。错！中本聪为了控制区块的生成时间，使区块的生成速率满足全网的每10分钟一个的标准，制定了严格的区块生成校验规则，也就是说，能不能生成一个成功的区块要看你的编号是否符合这个规则。例如：生成编号中的前n位必须为‘0’。

由于区块的交易内容是无法修改的，因此矿工们只能通过修改nonce去不断尝试这个函数，直到生成了一个成功的区块为止。如果当区块平均生成时间变快或者变慢，那么系统会对区块校验规则进行相应的调整，从而使平均的生成时间能够控制在规定范围。

如果一个矿工完成了一个区块，会立刻告知其他矿工，如果其他矿工此时没有完成新的区块生成，则会停下手头的工作，对区块进行验证，需要确认的信息主要有如下几点：

1）.区块的编号有效；这个只要将区块放入哈希函数中，看产生的编号是否和该区块中的编号一致即可。

2）.区块的前一个区块有效；之前提过，区块是一个串联的，每一个普通区块都会记载前一个区块的编号，这需要其他矿工对比当前的区块链的最后一个区块，看是否相同。

3）.交易清单有效；就是说要验证A到底有没有这一个btc可以给B。在区块链的交易信息中，会记录交易中所有btc的前世今生，区块链可以做到追本溯源，因此每一个btc在哪里，为什么在这里都可以一目了然，所以这点也没问题。

当验证完一个全新的区块后，全网就会认为这个区块有效，会将它添加到现有的区块链末端，同时结束针对该区块的挖矿工作，投入到下一个挖矿周期中。

(3)但是不难想象，这样的机制是存在冲突的隐患的，就是这么巧，两个矿工同时制作了一个正确的区块，那么此时不必二选一，可以将原来线性的区块链改成树状：

   

但是这样会导致未来在A、B后都会增加相应的区块，那么谁长谁将作为主链延伸下去，另一个也许会渐渐被遗忘，除非哪天它变得更长。

3 区块链Python代码实现 

话不多说，我们看看如何用python代码把最基本的区块链原理编写出来。首先我们看区块链的数据结构，它包含三部分信息，一是用于标志自己的id,它是一个整数，第二个是用于记录前一个区块的id，也是一个整数，由于区块用于记录信息，因此它还包含一个字段，我们用history来表示，这个字段用来记录当前发生了的信息，区块链最大的作用就是让这段信息可验证而且不可更改，我们先看数据结构的定义,先创建文件block.：

class Block:
    def __init__(self):
        self.id = None
        self.history = None
        self.parent_id = None

接下来我们看看区块如何行成”链“，同时如何记录信息。假设我们想要记录这么一个事件：张三想跟李四用一百块买三条鱼，李四收到一百块后给了张三三条鱼”，那么我们可以使用下面代码用区块链进行记录,创建main.py，然后给出如下代码: 

from block import *

block_A = Block()
block_A.id = 1
block_A.history = '张三想要三条鱼'

block_B = Block()
block_B.id = 2
block_B.parent_id = block_A.id
block_B.history = '张三跟李四买三条鱼'

block_C = Block()
block_C.id = 3
block_C.parent_id = block_B.id
block_C.history = '张三给李四一百块'

block_D = Block()
block_D.id = 3
block_D.parent_id = block_B.id
block_D.history = '李四收到张三一百块'

block_E = Block()
block_E.id = 3
block_E.parent_id = block_B.id
block_E.history = '李四给张三三条鱼'

从代码上看不同区块之间通过parent_id形成了前后连接关系，这就是区块链中的“链”，但现在还有一个严重问题，那就是信息可以更改，假设张三想来着，他把block_E里面的history改成李四给张三两条鱼，然后找李四算账那怎办，或者李四想赖账，把block_D中的history改成“李四收到张三五十块”，然后又找张三要钱，那怎么办。

为了确保信息不被更改，我们需要对每个区块的内容进行加密或者哈希，因此上面代码修改如下： 

这里需要一些知识储备，我已经总结好了：学习区块链的几个小知识（Python实现） 

from block import *
import hashlib
import json

block_A = Block()
block_A.id = 1
block_A.history = '张三想要三条鱼'

block_B = Block()
block_B.id = 2
block_B.parent_id = block_A.id
block_B.history = '张三跟李四买三条鱼'
block_B.parent_hash = hashlib.sha256(json.dumps(block_A.__dict__).encode('utf-8')).hexdigest()

block_C = Block()
block_C.id = 3
block_C.parent_id = block_B.id
block_C.history = '张三给李四一百块'
block_C.parent_hash = hashlib.sha256(json.dumps(block_B.__dict__).encode('utf-8')).hexdigest()

block_D = Block()
block_D.id = 4
block_D.parent_id = block_C.id
block_D.history = '李四收到张三一百块'
block_D.parent_hash = hashlib.sha256(json.dumps(block_C.__dict__).encode('utf-8')).hexdigest()

block_E = Block()
block_E.id = 5
block_E.parent_id = block_B.id
block_E.history = '李四给张三三条鱼'
block_E.parent_hash = hashlib.sha256(json.dumps(block_D__dict__).encode('utf-8')).hexdigest()

有了哈希，如何任何一个区块被修改，那么当前区块和后续区块的哈希都得修改，例如李四把block_C的history改成“张三给李四五十块”，那么我们看到李四必须要把block_C到block_E的哈希全部改了，如果这条链很长的话，李四改起来就非常吃力。同时为了确保信息的可靠性，
张三和李四需要把上面的区块链发送给其他一百个人进行存储，这样一来张三或李四想要赖账那就更加困难，因为有一百个见证者。

区块链信息记录的特点是只增不删，因此张三想要赖账的话，他只能在上面基础上再增加一个区块，也就是block_F, 里面的history写上了“张三收到李四两条鱼”，然后将这个区块发给其他100个人，为了防止随意添加区块造成信息混乱的情况，在区块链中有一个专门的角色负责将新增的区块添加到现有的区块链上，这个角色拿到区块数据后，，在不考虑parent_hash字段的情况下将数据序列化，接着找到一个特定字符串，这个字符串必须满足给定要求，那就是它与区块序列化的数据合并后，算出来的哈希值必须以5个0开头，我们从代码上看看这是什么意思：

#proof-of-work
block_F = Block()
block_F.id = 6
block_E.parent_id = block_E.id
block_E.history = '李四给张三三条鱼'
#注意我们这里没有设置parent_hash字段
block_F_serialized = json.dumps(block_F.__dict__).encode('utf-8')
print(block_F_serialized)
for i in range(10000000):
    proof_of_work = str(i).encode('utf-8')
    result = hashlib.sha256(block_F_serialized + proof_of_work).hexdigest()
    if result[:5] == '00000': #哈希结果只有以5个0开头才能添加区块到公链
        print(proof_of_work)
        print(result)
        break 
    #找到特定字符串后获取回报，所谓挖矿就是干这个事情

上面代码运行后所得结果为:

b'{"id": 6, "history": null, "parent_id": null, "parent_hash": null}'
b'553448'
0000034ba1dabbf794212082b47a6bcc98cb33eed86d363993270ca58e243bb9

也就是说特定字符串内容为”553448”，它能使得新区块内容和它结合后算出来的哈希以5个0开头，专门负责给区块查找这种字符串的角色就叫“矿工”，这个查找过程就叫挖矿，一旦找到这个特定字符串后他就能获取回报，也就是加密货币。

现在我们实现了数据的修改很困难，同时区块的添加也需要付出一定成本，但假设李四就是拼了老命也想把以前记录的信息修改掉，并为此愿意付出一切代价，假设当前区块链有1000个数据块，他想修改第一个块记录的信息，于是他修改了后面999个数据块的数据，但原始数据被其他人掌握着，因此他自己修改的数据就不会被采纳。由于区块链数据被分布存储在不同地方，于是在某项地方数据可能会被修改，这样就会出现数据不一致的情况，区块链还有一个重要任务就是在这种情况下达成共识。

同时当有新的区块需要加入公链时，我们需要将新增区块通过广播的方式通知所有人，于是就有个问题，那就是有些人较早获得通知，有些获得通知较晚，更有可能你会同时收到多个消息，假设现在公链上最后一个消息编号为5，此时你同时收到了两个消息东边发来的消息为history:王五想跟李四买一斤虾；西边发来的消息为history:李六想跟张三买两条鱼，那么我们应该将哪个消息作为编号6呢，此时的做法是先等等，如果过了一会西边发来了5条消息，同时东边只发来2条消息，那么就把消息少的抛弃，将消息多的经过处理后添加到公链。

通过选择数据多的添加到公链有个好处就是让数据的修改变得几乎不可能，例如李四辛辛苦苦花了半小时修改了999个区块，然后想要广播给其他人，但是很可能这段时间内有10000个新区块生成，于是他修改的999个区块就会被丢弃掉，这样他就无法进行任何修改。这个过程其实涉及到非常复杂的分布式计算理论，我们无法简单使用代码实现。

4 致谢 

区块链是个神奇的技术，期望未来区块链可以真的带来巨大的变革。要知道，随着AI的兴起，区块链的问世，属于程序员的数字时代会进一步升华，互联网时代只是一个开始！
————————————————
参考：https://blog.csdn.net/BmwGaara/article/details/79059007

什么是区块链

一个维护着一个持续增长的有序数据记录列表的这么一个分布式数据库

下面我将简单用nodejs实现一个简单的区块链，它具有区块链的基本特性，但没有涉及PoS of PoW。

块结构

一个块Block一般有：

• index 块号
• previousHash 上一个区块的hash值
• timestamp 时间戳
• data 存放的数据
• hash 区块的hash值

class Block {
    constructor(index, previousHash, timestamp, data, hash) {
        this.index = index;
        this.previousHash = previousHash;
        this.timestamp = timestamp;
        this.data = data;
        this.hash = hash.toString();
    }
    toString(){
        return "\n{\nindex:"+this.index+",\npreviousHash:'"+this.previousHash+"',\ntimestamp:"+this.timestamp+",\ndata:'"+this.data+"',\nhash:'"+this.hash+"'\n}\n"
    }
}

我们每生成一个区块，我们都会给这个区块按照特定的hash算法，来得到一个hash值，一般来说，只要这个区块的index,previoushash,timestamp,data有改动，那么它所算出的hash值也会改变，所以当你想要篡改某个区块的数据时，你需要将后面所有的区块的previoushash都进行篡改。

创世区块

第一个区块是没有前置hash的，是特殊的一个区块，我们用代码将这个区块写死

const genesisBlock = new Block.Block(
    0, null, 1619079309.946, "genesis block", '80dea37cccca5fb56b9b78dbe2733fb19e8ee2aa7bb03d4ac1e361fe3fad7b51'
);

hash

本文采用sha256来求得hash值

exports.caHash=function (index, previousHash, timestamp, data){
   	return sha256(index + previousHash + timestamp + data).toString();
}

验证块的有效性

下面是验证单个块是否有效，可以根据下面遍历整个链是否有效。

vaildBlock(block,lastBlock) {
        if (!Block.isValidBlockStructure(block))
            return false;
        if (
            (block.index==lastBlock.index+1)
            &&(block.previousHash==lastBlock.hash)
            &&Block.caHash(block.index,block.previousHash,block.timestamp,block.data)
        )
            return true;
        return false;
    }

记录数据

creatBlock(data){
        var lastBlock=this.getLastBlock();
        var newIndex=lastBlock.index+1;
        var newTime=new Date().getTime()/1000;
        var newPreHash=lastBlock.hash;
        var newhash=Block.caHash(newIndex,newPreHash,newTime,data.toString());
        return this.blocks[this.blocks.length]= new Block.Block(
            newIndex, newPreHash, newTime, data, newhash
        );

    }

从其他节点接收一个块

addBlock(block){
        if (validBlock(block,this.getLastBlock())){
            blocks.push(block);
            return true;
        }
        return false;
    }

编写测试代码

var Chain=require("./Chain");
var BlockChain=new Chain.BlockChain();
var http=require('http');
var fs=require('fs');
var querystring=require('querystring');

var server=http.createServer(function (req,res) {
    var url=req.url;
    if (url=="/get"){
        res.writeHead(200,{'content-type':'text/plain'+'charset=UTF8'});
        var str=BlockChain.blocks;
        res.end(str.toString());
    }else if (url=="/creat"){
        var data=[];
        req.on('data',function (chunk) {
            data.push(chunk);
        })
        req.on('end',function (chunk){
            var dataObj=querystring.parse(data.toString())
            BlockChain.creatBlock(dataObj["data"]);
            var lastblock=BlockChain.getLastBlock();
            res.setHeader('content-type','text/plain;charset=UTF8');
            res.write(lastblock.toString());
            res.end("生成区块"+lastblock.index+"号成功！");
        })

    }else {
        res.setHeader('content-type','text/html;charset=UTF8');
        fs.readFile('./client.html',function (err,data) {
            res.write(data);
            res.end();
        })
    }

});
server.listen(2345);

测试结果

输入一些数据，然后点击生成区块：

点击获取区块链：

完整代码

你可以从仓库里获取完整代码：

github: https://github.com/Lixingwei0623/ablockchain.
gitee: https://gitee.com/li-xingwei/simple-block-chain.

本文90%来着于翻译，原文地址：http://java-lang-programming.com/en/articles/29

概述

MerkleTree被广泛的应用在比特币技术中，本文旨在通过代码实现一个简单的MerkleTree，并计算出Merkle tree的 TreeRoot。
Merkle Tree 是一种数据结构，用于验证在计算机之间和之间存储，处理和传输的任何类型的数据。
目前，Merkle树的主要用途是确保从对等网络中接收的数据块未受损和未改变，和检查其他对等网络没有撒谎发送假数据块。

Merkle Tree应用举例

• 比特币
• Git
• Amazon’s Dynamo
• Gassandra

比特币中的应用

比特币中每个块中都包含了所有交易的集合签名，这个签名就是用Merkle tree实现的，Merkle树用于比特币以汇总块中的所有事务，产生整个事务集合的整体数字指纹，提供非常有效的过程来验证事务是否包括在块中。

Merkle树一个很重要的用处是检查块中是否包含指定的交易，Merkle树是通过递归哈希节点对来构造的，直到只有一个哈希。

Merkle tree 代码实现

哈希树的跟节点称为Merkle根，Merkle树可以仅用log2(N)的时间复杂度检查任何一个数据元素是否包含在树中：

package test;
import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.List;
public class MerkleTrees {
      // transaction List
      List<String> txList;
      // Merkle Root
      String root;

      /**
       * constructor
       * @param txList transaction List 交易List
       */
      public MerkleTrees(List<String> txList) {
        this.txList = txList;
        root = "";
      }

      /**
       * execute merkle_tree and set root.
       */
      public void merkle_tree() {

        List<String> tempTxList = new ArrayList<String>();

        for (int i = 0; i < this.txList.size(); i++) {
          tempTxList.add(this.txList.get(i));
        }

        List<String> newTxList = getNewTxList(tempTxList);

        while (newTxList.size() != 1) {
          newTxList = getNewTxList(newTxList);
        }

        this.root = newTxList.get(0);
      }

      /**
       * return Node Hash List.
       * @param tempTxList
       * @return
       */
      private List<String> getNewTxList(List<String> tempTxList) {

        List<String> newTxList = new ArrayList<String>();
        int index = 0;
        while (index < tempTxList.size()) {
          // left
          String left = tempTxList.get(index);
          index++;
          // right
          String right = "";
          if (index != tempTxList.size()) {
            right = tempTxList.get(index);
          }
          // sha2 hex value
          String sha2HexValue = getSHA2HexValue(left + right);
          newTxList.add(sha2HexValue);
          index++;

        }

        return newTxList;
      }

      /**
       * Return hex string
       * @param str
       * @return
       */
      public String getSHA2HexValue(String str) {
            byte[] cipher_byte;
            try{
                MessageDigest md = MessageDigest.getInstance("SHA-256");
                md.update(str.getBytes());
                cipher_byte = md.digest();
                StringBuilder sb = new StringBuilder(2 * cipher_byte.length);
                for(byte b: cipher_byte) {
                  sb.append(String.format("%02x", b&0xff) );
                }
                return sb.toString();
            } catch (Exception e) {
                    e.printStackTrace();
            }

            return "";
      }

      /**
       * Get Root
       * @return
       */
      public String getRoot() {
        return this.root;
      }

    }

数据准备

我们将交易的数据，放入到List中：

List<String> tempTxList = new ArrayList<String>();
tempTxList.add("a");
tempTxList.add("b");
tempTxList.add("c");
tempTxList.add("d");
tempTxList.add("e");

实现过程

• 准备交易数据
• 计算出每个数据的hash值，从左到右逐步组成树的左右节点
• 执行循环知道最后只剩下一个数据
  

private List<String> getNewTxList(List<String> tempTxList) {
  List<String> newTxList = new ArrayList<String>();
  int index = 0;
  while (index < tempTxList.size()) {
    // left
    String left = tempTxList.get(index);
    index++;
    // right
    String right = "";
    if (index != tempTxList.size()) {
      right = tempTxList.get(index);
    }
    // sha2 hex value
    String sha2HexValue = getSHA2HexValue(left + right);
    newTxList.add(sha2HexValue);
    index++;
  }

测试

package test;
import java.util.ArrayList;
import java.util.List;
public class App {
      public static void main(String [] args) {
        List<String> tempTxList = new ArrayList<String>();
        tempTxList.add("a");
        tempTxList.add("b");
        tempTxList.add("c");
        tempTxList.add("d");
        tempTxList.add("e");

        MerkleTrees merkleTrees = new MerkleTrees(tempTxList);
        merkleTrees.merkle_tree();
        System.out.println("root : " + merkleTrees.getRoot());
      }
    }

执行结果

本文从简单二叉树的形式实现了简单的MerkleTree，计算出TreeRoot，但是实际上的的MerkleTree不拘谨与二叉树还可能是多叉树。