前面最开始构建了交易的基本模型，然后逐步实现了转账，集成了钱包地址。公链基本交易模块已然成型，还有些小的细节需要去实现和优化。
Coinbase奖励
我们知道，在比特币中每当矿工成功挖到一个区块，就会得到一笔奖励。这笔奖励包含在创币交易中，创币交易是一个区块中的第一笔交易。
目前的项目还没有引入多节点竞争挖矿，暂且认为每一个区块是转账的第一个发起人挖到的。如此，Coinbase奖励就应该添加到MineNewBlock方法里。
//2.新增一个区块到区块链 --> 包含交易的挖矿
func (blc *Blockchain) MineNewBlock(from []string, to []string, amount []string) {
//send -from '["chaors"]' -to '["xyx"]' -amount '["5"]'
//获取UTXO集
utxoSet := &UTXOSet{blc}
var txs []*Transaction
//作为奖励给矿工的奖励 暂时将这笔奖励给from[0] 挖矿成功后再转给挖矿的矿工
tx := NewCoinbaseTransaction(from[0])
txs = append(txs, tx)
//1.通过相关算法建立Transaction数组
for index, address := range from {
value, _ := strconv.Atoi(amount[index])
tx := NewTransaction(address, to[index], int64(value), utxoSet, txs)
txs = append(txs, tx)
}
...
...
}
UTXOSet
之前为了实现转账引入了UTXO的概念，但是我们每次在转账查询可用余额时，都会去遍历一遍数据库上的区块。这样，会随着区块链的不断扩张，转账时查询的成本越来越高。
毕竟，查询时我们只需要关注未花费的TxOutput信息，而不需要关注区块上其他信息。那么，我们为什么不把未花费的TxOutput信息单独存储来查询呢？
其实，比特币正是这样做的。Bitcoin将链上所有区块存储在blocks数据库,将所有UTXO的集存储在chainstate数据库。
于是，我们引入UTXOSet集用来实现UTXO集的数据库存储。
//存储未花费交易输出的数据库表
const UTXOTableName = "UTXOTableName"
type UTXOSet struct {
Blockchain *Blockchain
}
ResetUTXOSet
该方法初始化UTXO集的存储表，如果bucket 存在就先移除，然后从区块链中获取所有的未花费输出，最终将输出保存到 bucket 中。
// 重置数据库表
func (utxoSet *UTXOSet) ResetUTXOSet() {
err := utxoSet.Blockchain.DB.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(utxoTableName))
if b != nil {
err := tx.DeleteBucket([]byte(utxoTableName))
if err!= nil {
log.Panic(err)
}
}
b ,_ = tx.CreateBucket([]byte(utxoTableName))
if b != nil {
//[string]*TXOutputs
txOutputsMap := utxoSet.Blockchain.FindUTXOMap()
for keyHash,outs := range txOutputsMap {
txHash,_ := hex.DecodeString(keyHash)
b.Put(txHash,outs.Serialize())
}
}
return nil
})
if err != nil {
log.Panic(err)
}
}
既然是UTXO存储表的初始化，那么一般情况下它只被执行一次。这种特性和创世区块相似，所以我们需要把他的实现放到创世区块的创建中。
//1.创建创世区块
func CreateBlockchainWithGensisBlock(address string) *Blockchain {
...
...
//创建创世区块时候初始化UTXO表
utxoSet := &UTXOSet{blc}
utxoSet.ResetUTXOSet()
return blc
}
UTXO表存储格式
我们存储UTXO的目的也是为了转账时能够更快地查询余额，为了实现转账，UTXO表除了存储对应的未花费的TXOutput集，还需要存储这些TXOutput来自于哪一笔交易。
我们以交易的哈希为键，以该交易下TXOutput组成的数组为值来存储UTXO。
由于一个交易下可能存在多个TXOutput，显然可以用数组表示。我们引入TXOutputs类来表示，因为要存储这些TXOutput需要实现序列化。
TXOutputs
type TXOutputs struct {
UTXOS []*UTXO
}
// 序列化成字节数组
func (txOutputs *TXOutputs) Serialize() []byte {
var result bytes.Buffer
encoder := gob.NewEncoder(&result)
err := encoder.Encode(txOutputs)
if err != nil {
log.Panic(err)
}
return result.Bytes()
}
// 反序列化
func DeserializeTXOutputs(txOutputsBytes []byte) *TXOutputs {
var txOutputs TXOutputs
decoder := gob.NewDecoder(bytes.NewReader(txOutputsBytes))
err := decoder.Decode(&txOutputs)
if err != nil {
log.Panic(err)
}
return &txOutputs
}
FindUTXOMap
知道UTXO表的存储格式后，我们就需要能够找到区块链上所有的未花费的TXOutput，并且能够以UTXO表存储的格式返回。这个方法是基于Blockchain的。
// 查找未花费的UTXO[string]*TXOutputs 返回字典 键为所属交易的哈希，值为TXOutput数组
func (blc *Blockchain) FindUTXOMap() map[string]*TXOutputs {
blcIterator := blc.Iterator()
// 存储已花费的UTXO的信息
spentableUTXOsMap := make(map[string][]*TXInput)
utxoMaps := make(map[string]*TXOutputs)
for {
block := blcIterator.Next()
for i := len(block.Txs) - 1; i >= 0 ;i-- {
txOutputs := &TXOutputs{[]*UTXO{}}
tx := block.Txs[i]
// coinbase
if tx.IsCoinbaseTransaction() == false {
for _,txInput := range tx.Vins {
txHash := hex.EncodeToString(txInput.TxHash)
spentableUTXOsMap[txHash] = append(spentableUTXOsMap[txHash],txInput)
}
}
txHash := hex.EncodeToString(tx.TxHAsh)
WorkOutLoop:
for index,out := range tx.Vouts {
txInputs := spentableUTXOsMap[txHash]
if len(txInputs) > 0 {
isUnSpent := true
for _,in := range txInputs {
outPublicKey := out.Ripemd160Hash
inPublicKey := in.PublicKey
if bytes.Compare(outPublicKey,Ripemd160Hash(inPublicKey)) == 0{
if index == in.Vout {
isUnSpent = false
continue WorkOutLoop
}
}
}
if isUnSpent {
utxo := &UTXO{tx.TxHAsh,index,out}
txOutputs.UTXOS = append(txOutputs.UTXOS, utxo)
}
} else {
utxo := &UTXO{tx.TxHAsh,index,out}
txOutputs.UTXOS = append(txOutputs.UTXOS, utxo)
}
}
// 设置键值对
utxoMaps[txHash] = txOutputs
}
// 找到创世区块时退出
var hashInt big.Int
hashInt.SetBytes(block.PrevBlockHash)
if hashInt.Cmp(big.NewInt(0)) == 0 {
break
}
}
return utxoMaps
}
UTXOSet测试
我们在命令行新增一个命令用于打印目前UTXO表存储的内容。
test命令添加和解析
testCmd := flag.NewFlagSet("test", flag.ExitOnError)
...
...
switch os.Args[1] {
...
...
case "test":
//第二个参数为相应命令，取第三个参数开始作为参数并解析
err := testCmd.Parse(os.Args[2:])
if err != nil {
log.Panic(err)
}
}
...
...
//UTXOSet测试
if testCmd.Parsed() {
cli.TestMethod()
}
CLI_test.go
func (cli *CLI) TestMethod() {
fmt.Println("TestMethod")
blockchain := GetBlockchain()
defer blockchain.DB.Close()
utxoSet := &UTXOSet{blockchain}
utxoSet.ResetUTXOSet()
fmt.Println(blockchain.FindUTXOMap())
}
GetBalance
现在我们查询余额就不需要去遍历整个区块数据库了，只需要遍历存储UTXO的表即可。查询逻辑还是和之前一样，先要从表中查到对应地址的所有UTXO，然后累加他们的值。
// 3.查询余额
func (utxoSet *UTXOSet) GetBalance(address string) int64 {
UTXOS := utxoSet.FindUTXOsForAddress(address)
var amount int64
for _, utxo := range UTXOS {
amount += utxo.Output.Value
}
return amount
}
// 2.查询某个地址的UTXO
func (utxoSet *UTXOSet) FindUTXOsForAddress(address string) []*UTXO {
var utxos []*UTXO
err := utxoSet.Blockchain.DB.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(UTXOTableName))
// 游标
c := b.Cursor()
for k, v := c.First(); k != nil; k,v = c.Next() {
txOutputs := DeserializeTXOutputs(v)
for _, utxo := range txOutputs.UTXOS {
if utxo.Output.UnLockScriptPubKeyWithAddress(address) {
utxos = append(utxos,utxo)
}
}
}
return nil
})
if err != nil {
log.Panic(err)
}
return utxos
}
接下来，修改CLI中查询余额调用的方法即可。
//查询余额
func (cli *CLI) getBlance(address string) {
fmt.Println("地址：" + address)
blockchain := GetBlockchain()
defer blockchain.DB.Close()
//amount := blockchain.GetBalance(address) 引入UTXOSet前的方法
utxoSet := &UTXOSet{blockchain}
amount := utxoSet.GetBalance(address)
fmt.Printf("%s一共有%d个Token\n", address, amount)
}
send转账优化
我们来回忆一下转账的几个重要步骤：
1.找到发起方所有的UTXO
2.在1的UTXO集里找到符合该次转账条件的UTXO组合和该组合对应的代币总和。
3.发起转账
之前上面的1，2都是在Blockchain里实现，并需要遍历整个区块数据库。在引入UTXOSet之后就需要基于UTXOSet实现。
1.Blockchain.UTXOs --> UTXOSet.FindUnPackageSpendableUTXOS
2.Blockchain.FindSpendableUTXOs --> UTXOSet.FindSpendableUTXOs
显然，2的方法基本相同。但是1有所差别，因为之前的逻辑中Blockchain.UTXOs需要找到链上所有UTXO和未打包的UTXO，而引入UTXOSet之后链上的UTXO都在UTXO表中，我们只需要找到未打包的交易产生的UTXO即可。
找到未打包交易的UTXO
// 找到未打包交易的UTXO，对应TXOutput的TX的Hash和index
func (utxoSet *UTXOSet) FindUnPackageSpendableUTXOS(address string, txs []*Transaction) []*UTXO {
var unUTXOs []*UTXO
spentTXOutputs := make(map[string][]int)
for _,tx := range txs {
if tx.IsCoinbaseTransaction() == false {
for _, in := range tx.Vins {
//是否能够解锁
if in.UnlockWithAddress(address) {
key := hex.EncodeToString(in.TxHash)
spentTXOutputs[key] = append(spentTXOutputs[key], in.Vout)
}
}
}
}
for _,tx := range txs {
Work:
for index,out := range tx.Vouts {
if out.UnLockScriptPubKeyWithAddress(address) {
if len(spentTXOutputs) != 0 {
for hash,indexArray := range spentTXOutputs {
txHashStr := hex.EncodeToString(tx.TxHAsh)
if hash == txHashStr {
var isUnSpent =true
for _,outIndex := range indexArray {
if index == outIndex {
isUnSpent = false
continue Work
}
if isUnSpent {
utxo := &UTXO{tx.TxHAsh, index, out}
unUTXOs = append(unUTXOs, utxo)
}
}
} else {
utxo := &UTXO{tx.TxHAsh, index, out}
unUTXOs = append(unUTXOs, utxo)
}
}
} else {
utxo := &UTXO{tx.TxHAsh, index, out}
unUTXOs = append(unUTXOs, utxo)
}
}
}
}
return unUTXOs
}
找到未花费交易里满足当次交易的UTXO组合
//转账时查找可用的用于消费的UTXO组合
func (utxoSet *UTXOSet) FindSpendableUTXOs(address string,amount int64,txs []*Transaction) (int64,map[string][]int) {
unPackageUTXOS := utxoSet.FindUnPackageSpendableUTXOS(address, txs)
spentableUTXO := make(map[string][]int)
var value int64 = 0
for _, UTXO := range unPackageUTXOS {
value += UTXO.Output.Value
txHash := hex.EncodeToString(UTXO.TxHash)
spentableUTXO[txHash] = append(spentableUTXO[txHash], UTXO.Index)
if value >= amount{
return value, spentableUTXO
}
}
// 钱还不够
err := utxoSet.Blockchain.DB.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(UTXOTableName))
if b != nil {
c := b.Cursor()
UTXOBREAK:
for k, v := c.First(); k != nil; k, v = c.Next() {
txOutputs := DeserializeTXOutputs(v)
for _, utxo := range txOutputs.UTXOS {
value += utxo.Output.Value
txHash := hex.EncodeToString(utxo.TxHash)
spentableUTXO[txHash] = append(spentableUTXO[txHash], utxo.Index)
if value >= amount {
break UTXOBREAK
}
}
}
}
return nil
})
if err != nil {
log.Panic(err)
}
if value < amount{
fmt.Printf("%s found.余额不足...", value)
os.Exit(1)
}
return value, spentableUTXO
}
UTXOSet.Update
由于转账消耗了一定的UTXO，同时产生了一定的UTXO。所以转账之后需要对UTXO数据库表做更新以保持UTXO表存储的永远是最新的未花费的交易输出。
简单地梳理一下更新UTXO表的步骤:
1.找到最新添加到区块链上的区块
2.遍历区块交易，将所有交易输入集中到一个数组
3.遍历区块交易的交易输出，找到新增的未花费的TXOutput
4.在UTXO表中删除输入输入中已花费的TXOutput，并将未花费的TXOutput缓存
5.将3求出的和4缓存的TXOutput新增到UTXO表中
废话少说撸代码
//更新UTXO
func (utxoSet *UTXOSet) Update() {
// 1.找出最新区块
block := utxoSet.Blockchain.Iterator().Next()
// 未花费的UTXO 键为对应交易哈希，值为TXOutput数组
outsMap := make(map[string] *TXOutputs)
// 新区快的交易输入,这些交易输入引用的TXOutput被消耗，应该从UTXOSet删除
ins := []*TXInput{}
// 2.遍历区块交易找出交易输入
for _, tx := range block.Txs {
//遍历交易输入，
for _, in := range tx.Vins {
ins = append(ins, in)
}
}
// 2.遍历交易输出
for _, tx := range block.Txs {
utxos := []*UTXO{}
for index, out := range tx.Vouts {
//未花费标志
isUnSpent := true
for _, in := range ins {
if in.Vout == index && bytes.Compare(tx.TxHAsh, in.TxHash) == 0 &&
bytes.Compare(out.Ripemd160Hash, Ripemd160Hash(in.PublicKey)) == 0 {
isUnSpent = false
continue
}
}
if isUnSpent {
utxo := &UTXO{tx.TxHAsh,index,out}
utxos = append(utxos,utxo)
}
}
if len(utxos) > 0 {
txHash := hex.EncodeToString(tx.TxHAsh)
outsMap[txHash] = &TXOutputs{utxos}
}
}
//3. 删除已消耗的TXOutput
err := utxoSet.Blockchain.DB.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(UTXOTableName))
if b != nil {
for _, in := range ins {
txOutputsBytes := b.Get(in.TxHash)
//如果该交易输入无引用的交易哈希
if len(txOutputsBytes) == 0 {
continue
}
txOutputs := DeserializeTXOutputs(txOutputsBytes)
// 判断是否需要
isNeedDelete := false
//缓存来自该交易还未花费的UTXO
utxos := []*UTXO{}
for _, utxo := range txOutputs.UTXOS {
if in.Vout == utxo.Index && bytes.Compare(utxo.Output.Ripemd160Hash, Ripemd160Hash(in.PublicKey)) == 0 {
isNeedDelete = true
}else {
//txOutputs中剩余未花费的txOutput
utxos = append(utxos,utxo)
}
}
if isNeedDelete {
b.Delete(in.TxHash)
if len(utxos) > 0 {
preTXOutputs := outsMap[hex.EncodeToString(in.TxHash)]
preTXOutputs.UTXOS = append(preTXOutputs.UTXOS, utxos...)
outsMap[hex.EncodeToString(in.TxHash)] = preTXOutputs
}
}
}
// 4.新增交易输出到UTXOSet
for keyHash, outPuts := range outsMap {
keyHashBytes, _ := hex.DecodeString(keyHash)
b.Put(keyHashBytes, outPuts.Serialize())
}
}
return nil
})
if err != nil{
log.Panic(err)
}
}
Main_Test
package main
import (
"chaors.com/LearnGo/publicChaorsChain/part11-transaction_1_Prototype/BLC"
)
func main() {
cli := BLC.CLI{}
cli.Run()
}
创建区块链
main_test1.png
产生交易后
main_test2.png
到目前为止，公链的交易算是基本讲完了。
源代码在这,喜欢的朋友记得给个小star，或者fork.也欢迎大家一起探讨区块链相关知识，一起进步！
.
.
.
.
互联网颠覆世界，区块链颠覆互联网!
---------------------------------------------20180708 15:33
网友评论