POS代码实现

本篇文章主要是POS共识的简单实现，其中有许多地方都做了简化。POS的原理已在上篇文章中描述过，如果对POS的原理不太清晰的可以进行查看。文章地址：共识算法学习总结。

代码实现的功能有：添加区块、查看区块链、添加验证者以及查看所有的验证者。代码使用bolt数据库进行数据持久化。

创建一条区块链

系统运行时，首先运行命令创建一条区块链。该函数主要的功能：创建一个创世块，并把创世块保存在bolt数据库中。

func create() {
	// 生成创世块
	genesisBlock := common.Block{}
	genesisBlock = common.Block{
		0,
		time.Now().String(),
		"",
		GenerateHashValue(genesisBlock),
		"",
		common.Validator{},
	}

	// 获取bolt数据库句柄
	db := common.GetDB()
	defer db.Close()
	// 把创世块添加进数据库文件中
	db.Update(func(tx *bolt.Tx) error {

		// 获取bucket
		bucket, err := tx.CreateBucketIfNotExists([]byte(common.BlocksBucket))
		if err != nil{
			fmt.Println(err)
			return err
		}

		// 获取最后一个区块的哈希
		lastHash := bucket.Get([]byte("lastHash"))
		if lastHash == nil {
			bucket.Put([]byte("lastHash"), []byte(genesisBlock.HashCode))
			bucket.Put([]byte(genesisBlock.HashCode), serializeBlock(genesisBlock))
		}
		return err
	})
}

添加一个区块

当创建一个区块链后就可以往区块链中添加区块。当添加区块时首先开启共识模块，共识模块会在后面讲解。开启共识模块后，把输入的数据打包成区块，然后把区块添加到候选区块通道中，等待共识模块的确认。最后等待共识模块的完成。

func addBlock(data string)  {
	// 开始共识
	go consensus.Start()

	// 把客户端输入的数据封装成区块。这里做了简化，直接生成了区块。
	// 实际上应由验证者进行打包区块。
	newBlock := generateBlock(data)

	// 把新生成的区块添加到候选区块通道中
	common.CandidateBlokcs <- newBlock

	select {
	// 阻塞等待退出
	case <- common.ExitChan:
		return
	}
}

启动共识

在启动共识的函数中，首先开启一个协程，不断读取候选区块切片中的数据，如果读取到区块就把区块追加到临时区块切片中。协程启动完毕后就开始循环POS共识。

func Start(){
	// 不断读取候选区块通道，如果有新的区块，就追加到临时区块切片中
	go func() {
		for candidate := range common.CandidateBlokcs{
			fmt.Println("有新的临时区块")
			common.TempBlocks = append(common.TempBlocks, candidate)
		}
	}()


	for  {
		// 循环pos共识算法
		pos()
	}

}

POS共识

进入共识算法后，首先获取临时区块中的区块，接着获取所有的验证者并根据验证者的权重创建一个新的切片。在这个切片中，验证者的权重越高，重复的次数也就越多，也就越容易被选为出块节点。接着通过一个随机数挑选验证者并打包区块。

func pos()  {
	// 复制临时区块
	temp := common.TempBlocks

	// 根据temp的长度判断是否存在临时区块
	if len(temp) > 0{
		var tempValidators []common.Validator
		// 获取所有的验证者
		validators := getAllValidators()
		// 根据验证者拥有的token数量及时间得出权重，权重越高，被选取为出块节点的概率越大
		for i := 0; i < len(validators) - 1; i++{
			for j := 0; j < validators[i].Tokens * validators[i].Days; j++{
				tempValidators = append(tempValidators, validators[i])
			}
		}

		// 获取数据库句柄
		db := common.GetDB()
		defer db.Close()
		for _, block := range temp{
			// 挑选验证者
			rand.Seed(time.Now().Unix())
			var rd =rand.Intn(len(tempValidators))
			block.Validator = validators[rd %　len(validators)]
			// 持久化
			db.Update(func(tx *bolt.Tx) error {
				bucket := tx.Bucket([]byte(common.BlocksBucket))
				err := bucket.Put([]byte(block.HashCode), serializeBlock(block))
				if err != nil {
					log.Fatal(err)
				}
				err = bucket.Put([]byte("lastHash"), []byte(block.HashCode))
				if err != nil {
					log.Fatal(err)
				}
				return nil
			})
		}
		mutex.Lock()
		common.ExitChan <- true
		common.TempBlocks = []common.Block{}
		temp = []common.Block{}
		mutex.Unlock()
	}
}

添加验证者

添加验证者时，需要指定验证者的token数量。验证者的地址用时间来模拟。最后把验证者持久化到数据库中，键为验证者的地址，值为序列化后的验证者。

func addValidator(token int)  {
	// 验证者的地址用当前时间的sha256值代替
	address := calculateHash(time.Now().String())

	// 创建一个验证者
	validator := common.Validator{
		token,
		time.Now().Second(),
		address,
	}

	// 添加到数据库中
	db := common.GetDB()
	defer db.Close()
	db.Update(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte(common.PeerBucket))
		err := bucket.Put([]byte(validator.Address), serializeValidator(validator))
		if err != nil {
			log.Fatal(err)
			return err
		}
		return nil
	})
}

查看验证者

查看验证者比较简单，只是查询一下数据库并进行打印。

func view()  {
	var validators []common.Validator

	db := common.GetDB()
	defer db.Close()
	db.View(func(tx *bolt.Tx) error {
		bucket := tx.Bucket([]byte(common.PeerBucket))
		cursor := bucket.Cursor()

		for k, v := cursor.First(); k != nil; k, v = cursor.Next(){
			if string(k) == "lastHash"{
				continue
			}
			block := deserializeValidator(v)
			validators = append(validators, block)
		}
		return nil
	})

	spew.Dump(validators)
}

运行结果

最后

项目中做了很多简化并且有很多设计不合理的地方，以后会继续进行改进。源码：https://github.com/blockchainGuide/Consensus_Algorithm