上节已基本实现硬编码转账并查询余额，今天真正地实现转账函数并对相关函数做一个优化。
UTXO
UTXO 代表 Unspent Transaction TxOutput,表示区块链上未经花费的交易输出。简单地说，UTXO还没有被包含在任何的交易输入中。根据UTXO可以知道对应TxOutput来自哪一笔交易，以及其在Vounts中的下标。
type UTXO struct {
//来自交易的哈希
TxHash []byte
//在该交易VOuts里的下标
Index int
//未花费的交易输出
Output *TXOutput
}
UTXOs函数改造
有了UTXO的结构后，我们就可以改造上次获取未花费输出的方法，使其返回为UTXO类型的数组。
其次，之前测试的都是单笔转账的交易。当出现多笔转账的交易时，我们现有的查询余额方法会不准确。为什么呢？
当一笔交易中有多个转账，当进行其中第二笔转账时，第一笔转账已经成功。但是，我们此时查询的依然是区块链上所有交易的UTXO。因此，我们还需要在UTXOs方法中加上当前未上链的所有交易的UTXO。
这时就有疑问了，不是只有上链的交易才会有效吗？事实是这样的，但是看目前的项目，由于还没有引入竞争挖矿的概念，每一次send必然会挖矿成功，其交易必然会上链。所以我们需要暂时这么做。
//5.返回一个地址对应的UTXO的交易UTXOs
//func (blc *Blockchain) UnSpentTransactionsWithAddress(address string) []*Transaction {
func (blc *Blockchain) UTXOs(address string, txs []*Transaction) []*UTXO {
//未花费的TXOutput
var utxos []*UTXO
//已经花费的TXOutput [hash:[]] [交易哈希：TxOutput对应的index]
var spentTXOutputs = make(map[string][]int)
//遍历器处理区块链上的UTXO
blcIterator := blc.Iterator()
for {
block := blcIterator.Next()
//fmt.Println(block)
//fmt.Println()
for _, tx := range block.Txs {
// txHash
// Vins
//判断当前交易是否为创币交易
if tx.IsCoinbaseTransaction() == false {
for _, in := range tx.Vins {
//验证当前输入是否是当前地址的
if in.UnlockWithAddress(address) {
key := hex.EncodeToString(in.TxHash)
//fmt.Printf("lll%x\n", in.TxHash)
//fmt.Println(key)
spentTXOutputs[key] = append(spentTXOutputs[key], in.Vout)
}
}
}
// Vouts
Work:
for index, out := range tx.Vouts {
//验证当前输出是否是
if out.UnLockScriptPubKeyWithAddress(address) {
//fmt.Println(out)
//fmt.Println(spentTXOutputs)
//判断是否曾发生过交易
if spentTXOutputs != nil {
if len(spentTXOutputs) != 0 {
//未花费UTXO标志
isUnSpentUTXO := true
//遍历spentTXOutputs
for txHash, indexArray := range spentTXOutputs {
//遍历TXOutputs下标数组
for _, i := range indexArray {
if index == i && txHash == hex.EncodeToString(tx.TxHAsh) {
isUnSpentUTXO = false
continue Work
}
}
}
if isUnSpentUTXO {
utxo := &UTXO{tx.TxHAsh, index, out}
utxos = append(utxos, utxo)
}
} else {
utxo := &UTXO{tx.TxHAsh, index, out}
utxos = append(utxos, utxo)
}
}
}
}
}
//找到创世区块，跳出循环
var hashInt big.Int
hashInt.SetBytes(block.PrevBlockHash)
// Cmp compares x and y and returns:
//
// -1 if x < y
// 0 if x == y
// +1 if x > y
if hashInt.Cmp(big.NewInt(0)) == 0 {
break
}
}
//处理未打包到区块链上的交易集里的UTXO
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 {
Work1:
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 {
isUnSpentUTXO := true
for _, outIndex := range indexArray {
if index == outIndex {
isUnSpentUTXO = false
continue Work1
}
if isUnSpentUTXO {
utxo := &UTXO{tx.TxHAsh, index, out}
utxos = append(utxos, utxo)
}
}
} else {
utxo := &UTXO{tx.TxHAsh, index, out}
utxos = append(utxos, utxo)
}
}
} else {
utxo := &UTXO{tx.TxHAsh, index, out}
utxos = append(utxos, utxo)
}
}
}
}
return utxos
}
TXInput和TXOutput解锁
上面UTXOs方法求得是某一个address的所有UTXO，目前我们还没有引入钱包地址的概念，姑且理解这个address为用户名。我们要想保证查询的是某个用户(address)交易输入和输出是属于这个用户的，必须有一个保障的机制。
//验证当前输入是否是当前地址的
func (txInput *TXInput) UnlockWithAddress(address string) bool {
return txInput.ScriptSig == address
}
//验证当前交易输出属于某用户
func (txOutput *TXOutput) UnLockScriptPubKeyWithAddress(address string) bool {
return txOutput.ScriptPubKey == address
}
FindSpendableUTXOs
当我们进行一笔转账时，交易输入有可能引用一个UTXO，也可能引用多个UTXO。在获取转账方所有的UTXO后，还需要找到符合条件的UTXO组合作为交易输入的引用。这个时候可能出现用户余额不足以转账的情况，也可能出现UTXO组合价值大于转账金额产生找零的情况。
为了方便地判断UTXO来源以及计算转账后的找零，我们需要想办法在当前用户的所有UTXO中找到一个满足当前转账情况的UTXO集，并返回其UTXO总额和对应的UTXO集。而这个UTXO集是一个字典类型，键是UTXO来源交易的哈希，值对该交易下UTXO对应TXOutput在Vounts中的下标。
//转账时查找可用的用于消费的UTXO 返回输入总金额和一个字典，UTXO集是一个字典类型，键是UTXO来源交易的哈希，值对该交易下UTXO对应TXOutput在Vounts中的下标
func (blc *Blockchain) FindSpendableUTXOs(address string, amount int, txs []*Transaction) (int64, map[string][]int) {
//1.获取当前地址所有UTXO
utxos := blc.UTXOs(address, txs)
spendableUTXO := make(map[string][]int)
//2.遍历UTXO
//总的金额
var value int64
for _, utxo := range utxos {
value += utxo.Output.Value
txHash := hex.EncodeToString(utxo.TxHash)
spendableUTXO[txHash] = append(spendableUTXO[txHash], utxo.Index)
if value >= int64(amount) {
break
}
}
//余额不足
if value < int64(amount) {
fmt.Println("%s found.余额不足...", value)
os.Exit(1)
}
return value, spendableUTXO
}
NewTransaction
上次我们硬编码测试了几笔交易，这回有了上面的基础方法就可以对普通交易的构造做一个代码实现。
//2.普通交易
func NewTransaction(from string, to string, amount int, blc *Blockchain, txs []*Transaction) *Transaction {
//获取from用户用于这笔交易的总输入金额和UTXO集
money, spendableUTXODic := blc.FindSpendableUTXOs(from, amount, txs)
//输入输出
var txInputs []*TXInput
var txOutputs []*TXOutput
//遍历spendableUTXODic来组装TXInput作为该交易的交易输入
for txHash, indexArr := range spendableUTXODic {
//字符串转换为[]byte
txHashBytes, _ := hex.DecodeString(txHash)
for _, index := range indexArr {
//交易输入
txInput := &TXInput{
txHashBytes,
index,
from,
}
txInputs = append(txInputs, txInput)
}
}
//转账
txOutput := &TXOutput{
int64(amount),
to,
}
txOutputs = append(txOutputs, txOutput)
//找零
txOutput = &TXOutput{
money-int64(amount),
from,
}
txOutputs = append(txOutputs, txOutput)
//交易构造
tx := &Transaction{
[]byte{},
txInputs,
txOutputs,
}
tx.HashTransactions()
return tx
}
MineNewBlock
理论上我们的交易是支持多笔转账的，可是上面构建交易的方法是针对一笔交易。所以，我们需要在发起交易挖掘区块的方法里对cli输入的多笔交易信息做一个遍历并生成多笔交易数据。
//2.新增一个区块到区块链 --> 包含交易的挖矿
func (blc *Blockchain) MineNewBlock(from []string, to []string, amount []string) {
//send -from '["chaors"]' -to '["xyx"]' -amount '["5"]'
//1.通过相关算法建立Transaction数组
var txs []*Transaction
//遍历输入输出，组装多笔交易
for index, address := range from {
value, _ := strconv.Atoi(amount[index])
tx := NewTransaction(address, to[index], value, blc, txs)
txs = append(txs, tx)
}
//2.挖矿
//取上个区块的哈希和高度值
var block *Block
err := blc.DB.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blockTableName))
if b != nil {
hash := b.Get([]byte(newestBlockKey))
blockBytes := b.Get(hash)
block = DeSerializeBlock(blockBytes)
}
return nil
})
if err != nil {
log.Panic(err)
}
//3.建立新区块
block = NewBlock(txs, block.Height+1, block.Hash)
//4.存储新区块
err = blc.DB.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(blockTableName))
if b != nil {
//fmt.Printf("444---%x\n\n", block.Txs[0].Vins[0].TxHash)
//fmt.Println(block)
err = b.Put(block.Hash, block.Serialize())
if err != nil {
log.Panic(err)
}
err = b.Put([]byte(newestBlockKey), block.Hash)
if err != nil {
log.Panic(err)
}
blc.Tip = block.Hash
}
return nil
})
if err != nil {
log.Panic(err)
//fmt.Print(err)
}
}
CLI优化
上面已经基本实现了多笔交易的打包并挖矿。接下来，我们看一下CLI.go文件的结构：
type CLI struct {
}
//打印目前左右命令使用方法
func printUsage() {
fmt.Println("Usage:")
fmt.Println("\tcreateBlockchain -address --创世区块地址 ")
fmt.Println("\tsend -from FROM -to TO -amount AMOUNT --交易明细")
fmt.Println("\tprintchain --打印所有区块信息")
fmt.Println("\tgetbalance -address -- 输出区块信息.")
}
func isValidArgs() {
//获取当前输入参数个数
if len(os.Args) < 2 {
printUsage()
os.Exit(1)
}
}
func (cli *CLI) Run() {
isValidArgs()
//自定义cli命令
sendBlockCmd := flag.NewFlagSet("send", flag.ExitOnError)
printchainCmd := flag.NewFlagSet("printchain", flag.ExitOnError)
createBlockchainCmd := flag.NewFlagSet("createBlockchain", flag.ExitOnError)
blanceBlockCmd := flag.NewFlagSet("getBalance", flag.ExitOnError)
//addBlockCmd 设置默认参数
flagSendBlockFrom := sendBlockCmd.String("from", "", "源地址")
flagSendBlockTo := sendBlockCmd.String("to", "", "目标地址")
flagSendBlockAmount := sendBlockCmd.String("amount", "", "转账金额")
flagCreateBlockchainAddress := createBlockchainCmd.String("address", "", "创世区块地址")
flagBlanceBlockAddress := blanceBlockCmd.String("address", "", "输出区块信息")
//解析输入的第二个参数是addBlock还是printchain，第一个参数为./main
switch os.Args[1] {
case "send":
//第二个参数为相应命令，取第三个参数开始作为参数并解析
err := sendBlockCmd.Parse(os.Args[2:])
if err != nil {
log.Panic(err)
}
case "printchain":
err := printchainCmd.Parse(os.Args[2:])
if err != nil {
log.Panic(err)
}
case "createBlockchain":
err := createBlockchainCmd.Parse(os.Args[2:])
if err != nil {
log.Panic(err)
}
case "getBalance":
err := blanceBlockCmd.Parse(os.Args[2:])
if err != nil {
log.Panic(err)
}
default:
printUsage()
os.Exit(1)
}
//对addBlockCmd命令的解析
if sendBlockCmd.Parsed() {
if *flagSendBlockFrom == "" {
printUsage()
os.Exit(1)
}
if *flagSendBlockTo == "" {
printUsage()
os.Exit(1)
}
if *flagSendBlockAmount == "" {
printUsage()
os.Exit(1)
}
//cli.addBlock(*flagAddBlockData)
//这里真正地调用转账方法
//fmt.Println(*flagSendBlockFrom)
//fmt.Println(*flagSendBlockTo)
//fmt.Println(*flagSendBlockAmount)
//
//fmt.Println(Json2Array(*flagSendBlockFrom))
//fmt.Println(Json2Array(*flagSendBlockTo))
//fmt.Println(Json2Array(*flagSendBlockAmount))
cli.send(
Json2Array(*flagSendBlockFrom),
Json2Array(*flagSendBlockTo),
Json2Array(*flagSendBlockAmount),
)
}
//对printchainCmd命令的解析
if printchainCmd.Parsed() {
cli.printchain()
}
//
if createBlockchainCmd.Parsed() {
if *flagCreateBlockchainAddress == "" {
cli.creatBlockchain(*flagCreateBlockchainAddress)
}
cli.creatBlockchain(*flagCreateBlockchainAddress)
}
if blanceBlockCmd.Parsed() {
if *flagBlanceBlockAddress == "" {
printUsage()
os.Exit(1)
}
cli.getBlance(*flagBlanceBlockAddress)
}
}
不难返现逻辑不是很清晰，既有cli命令的定义和解析，又有具体命令的实现。按照单一职责的设计原则，这里应该只有cli命令的定义和解析，具体命令的解析应该拆分到相应文件。这样显得脉络清晰，逻辑明了。
例如，我们可以吧创建区块链命令的具体实现分离到一个CLI_createBlockchain.go文件：
//新建区块链
func (cli *CLI)creatBlockchain(address string) {
blockchain := CreateBlockchainWithGensisBlock(address)
defer blockchain.DB.Close()
}
目前CLI支持的命令还有，打印区块链(printchain)，获取余额(getBlance)，转账(send)，我们按照上面的处理方式分别把代码分离就可以了。最终，项目会多出这几个文件：
CLI优化.png
至此，就基本实现了公链的转账功能。
源代码在这,喜欢的朋友记得给个小star，或者fork.也欢迎大家一起探讨区块链相关知识，一起进步！
.
.
.
.
互联网颠覆世界，区块链颠覆互联网!
---------------------------------------------20180705 22:24
网友评论