在本篇博客中，我们将深入探讨一个用Go语言编写的简易区块链实现。通过这个示例，我们可以理解区块链背后的核心概念，包括如何创建和管理区块、如何处理交易以及如何通过工作量证明算法保证区块链的安全性。我们还会探讨如何使用BoltDB这个轻量级的键值数据库来持久化存储区块链数据。在这个过程中，我们将一步一步构建起区块链的基本结构，并演示如何通过命令行界面（CLI）与区块链进行交互。

建议观看顺序：

Go语言实现简单区块链-CSDN博客

Go语言实现简单区块链——增加POW机制-CSDN博客

1.block.go

区块的序列化与反序列化

为了能够在网络中传输或在磁盘上存储，我们需要将区块序列化和反序列化。序列化是将区块转换为字节序列的过程，而反序列化是将字节序列还原为原始区块的过程。

• 序列化 (Serialize 方法): 使用Go的encoding/gob包来进行序列化操作。这个方法将Block结构体编码成字节流，以便于存储或网络传输。

• 反序列化 (DeserializeBlock 函数): 与序列化相反，这个函数将字节流解码回Block结构体。

区块的创建

• 新建区块 (NewBlock 函数): 当需要添加新的区块时，我们会调用这个函数。该函数接受交易列表和前一个区块的哈希值作为参数，创建一个新的区块。在这个过程中，我们还会进行工作量证明的计算。

• 创世区块 (NewGenesisBlock 函数): 创世区块是区块链中的第一个区块。这个函数通过调用NewBlock函数并传递一个特殊的coinbase交易来创建创世区块。

// -*- coding: utf-8 -*- // Time    : 2024/4/15 22:15 // Author  : blue // File    : block.go // Software: Goland package main  import ( 	"bytes" 	"crypto/sha256" 	"encoding/gob" 	"log" 	"time" )  // Block keeps block headers type Block struct { 	Timestamp     int64          // 时间戳 	Transactions  []*Transaction // 交易 	PrevBlockHash []byte         // 前一个区块的哈希 	Hash          []byte         // 当前区块的哈希 	Nonce         int            // 随机数 }  // Serializes 是将区块序列化为字节数组 func (b *Block) Serialize() []byte { 	var result bytes.Buffer 	encoder := gob.NewEncoder(&result)  	err := encoder.Encode(b) 	if err != nil { 		log.Panic(err) 	}  	return result.Bytes() }  // HashTransactions将区块中的所有交易序列化并返回一个哈希值 func (b *Block) HashTransactions() []byte { 	var txHashes [][]byte 	var txHash [32]byte // 遍历区块中的所有交易 	for _, tx := range b.Transactions { 		txHashes = append(txHashes, tx.ID) 	} 	txHash = sha256.Sum256(bytes.Join(txHashes, []byte{}))  	return txHash[:] }  // NewBlock 将创建一个新的区块 func NewBlock(transactions []*Transaction, prevBlockHash []byte) *Block { 	// 创建区块 	block := &Block{time.Now().Unix(), transactions, prevBlockHash, []byte{}, 0} 	// 创建工作量证明 	pow := NewProofOfWork(block) 	// 运行工作量证明 	nonce, hash := pow.Run()  	block.Hash = hash[:] 	block.Nonce = nonce  	return block }  // NewGenesisBlock 将创建并返回创世区块 func NewGenesisBlock(coinbase *Transaction) *Block { 	return NewBlock([]*Transaction{coinbase}, []byte{}) }  // DeserializeBlock 将区块的字节数组反序列化为区块 func DeserializeBlock(d []byte) *Block { 	var block Block  	decoder := gob.NewDecoder(bytes.NewReader(d)) 	err := decoder.Decode(&block) 	if err != nil { 		log.Panic(err) 	}  	return &block } 

 2.blockchains.go

 这段代码实现了区块链的核心数据结构和功能，包括区块链、区块迭代器以及创建、查询和添加区块等操作。让我们深入分析：

数据结构

• Blockchain: 区块链结构体，包含最新区块的哈希值和数据库指针。
• BlockchainIterator: 区块链迭代器，用于遍历区块链，包含当前区块的哈希值和数据库指针。

函数解析

• MineBlock: 挖矿函数，根据交易列表创建新区块，并将其添加到区块链中。
  • 首先获取最新区块的哈希值。
  • 然后创建新的区块，并进行工作量证明计算。
  • 最后将新区块序列化并存储到数据库中，更新区块链的最新区块哈希值。
• FindUnspentTransactions: 查找指定地址的未花费交易。
  • 遍历区块链，检查每个交易的输出是否属于指定地址，以及是否已被花费。
  • 将未花费的交易添加到结果列表中。
• FindUTXO: 查找指定地址的未花费交易输出 (UTXO)。
  • 调用 FindUnspentTransactions 获取未花费交易。
  • 遍历未花费交易的输出，将属于指定地址的输出添加到结果列表中。
• FindSpendableOutputs: 查找满足指定金额的未花费交易输出。
  • 遍历未花费交易的输出，累加金额，直到满足指定金额。
  • 返回累加金额和满足条件的未花费交易输出。
• Iterator: 创建区块链迭代器，从最新区块开始遍历区块链。
• Next: 获取区块链迭代器指向的当前区块，并将迭代器指向下一个区块。
• dbExists: 检查区块链数据库文件是否存在。
• NewBlockchain: 打开区块链数据库，并创建区块链对象。
• CreateBlockchain: 创建新的区块链，包含创世区块。
  • 首先创建 coinbase 交易，奖励给指定地址。
  • 然后创建创世区块，包含 coinbase 交易。
  • 最后将创世区块存储到数据库中，并创建区块链对象。
• AddBlock: 添加新区块到区块链。
  • 首先创建 coinbase 交易，奖励给指定地址。
  • 然后调用MineBlock挖矿并添加新区块到区块链中。

// -*- coding: utf-8 -*- // Time    : 2024/4/15 22:15 // Author  : blue // File    : blockchains.go // Software: Goland package main  import ( 	"encoding/hex" 	"fmt" 	"github.com/boltdb/bolt" 	"log" 	"os" )  const dbFile = "blockchain.db"                                                                      //数据库文件 const blocksBucket = "blocks"                                                                       //存储区块的桶 const genesisCoinbaseData = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks" //创世块的交易数据  // Blockchain 包含一个区块链 type Blockchain struct { 	tip []byte   //最新区块的哈希 	db  *bolt.DB //数据库指针 }  // BlockchainIterator 将用于迭代区块链 type BlockchainIterator struct { 	currentHash []byte   //当前区块的哈希 	db          *bolt.DB //数据库指针 }  // MineBlock 将用于挖掘新块 func (bc *Blockchain) MineBlock(transactions []*Transaction) { 	var lastHash []byte //记录最新区块的哈希 	//获取最新区块的哈希 	err := bc.db.View(func(tx *bolt.Tx) error { 		//获取区块桶 		b := tx.Bucket([]byte(blocksBucket)) 		//获取最新区块的哈希 		lastHash = b.Get([]byte("l")) 		return nil 	})  	if err != nil { 		log.Panic(err) 	} 	//创建新区块（包含验证） 	newBlock := NewBlock(transactions, lastHash) 	//将新区块存储到数据库中 	err = bc.db.Update(func(tx *bolt.Tx) error { 		//获取区块桶 		b := tx.Bucket([]byte(blocksBucket)) 		//将新区块存储到数据库中 		err := b.Put(newBlock.Hash, newBlock.Serialize()) 		if err != nil { 			log.Panic(err) 		} 		//将最新区块的哈希存储到数据库中 		err = b.Put([]byte("l"), newBlock.Hash) 		if err != nil { 			log.Panic(err) 		} 		//更新区块链的tip 		bc.tip = newBlock.Hash  		return nil 	}) }  // FindUnspentTransactions 返回未花费的交易 func (bc *Blockchain) FindUnspentTransactions(address string) []Transaction { 	//未花费的交易 	var unspentTXs []Transaction 	//已花费的输出 	spentTXOs := make(map[string][]int) 	//迭代区块链 	bci := bc.Iterator() 	for { 		//获取下一个区块 		block := bci.Next() 		//遍历区块中的交易 		for _, tx := range block.Transactions { 			//将交易ID转换为字符串 			txID := hex.EncodeToString(tx.ID) 		Outputs: 			//遍历交易中的输出 			for outIdx, out := range tx.Vout { 				//检查输出是否已经被花费 				if spentTXOs[txID] != nil { 					//遍历已花费的输出 					for _, spentOut := range spentTXOs[txID] { 						//如果输出已经被花费，则跳过 						if spentOut == outIdx { 							continue Outputs 						} 					} 				} 				//如果输出可以被解锁，则将交易添加到未花费的交易中 				if out.CanBeUnlockedWith(address) { 					unspentTXs = append(unspentTXs, *tx) 				} 			} 			//如果交易不是coinbase交易，则遍历交易的输入 			if tx.IsCoinbase() == false { 				//遍历交易的输入 				for _, in := range tx.Vin { 					//如果输入可以解锁，则将输出添加到已花费的输出中 					if in.CanUnlockOutputWith(address) { 						//将交易ID转换为字符串 						inTxID := hex.EncodeToString(in.Txid) 						//将输出添加到已花费的输出中 						spentTXOs[inTxID] = append(spentTXOs[inTxID], in.Vout) 					} 				} 			} 		} 		//如果区块的前一个区块哈希为空，则退出循环 		if len(block.PrevBlockHash) == 0 { 			break 		} 	} 	//返回未花费的交易 	return unspentTXs }  // FindUTXO 返回未花费的输出 func (bc *Blockchain) FindUTXO(address string) []TXOutput { 	var UTXOs []TXOutput 	//未花费的交易 	unspentTransactions := bc.FindUnspentTransactions(address) 	//遍历未花费的交易 	for _, tx := range unspentTransactions { 		//遍历交易的输出 		for _, out := range tx.Vout { 			//如果输出可以被解锁，则将输出添加到未花费的输出中 			if out.CanBeUnlockedWith(address) { 				UTXOs = append(UTXOs, out) 			} 		} 	}  	return UTXOs }  // FindSpendableOutputs 返回足够的未花费输出以满足要求的金额 func (bc *Blockchain) FindSpendableOutputs(address string, amount int) (int, map[string][]int) { 	//未花费的输出 	unspentOutputs := make(map[string][]int) 	//未花费的交易 	unspentTXs := bc.FindUnspentTransactions(address) 	//累计金额 	accumulated := 0  Work: 	//遍历未花费的交易 	for _, tx := range unspentTXs { 		//将交易ID转换为字符串 		txID := hex.EncodeToString(tx.ID) 		//遍历交易的输出 		for outIdx, out := range tx.Vout { 			//如果输出可以被解锁且累计金额小于要求的金额，则将输出添加到未花费的输出中 			if out.CanBeUnlockedWith(address) && accumulated < amount { 				//将输出添加到未花费的输出中 				accumulated += out.Value 				//将输出的索引添加到未花费的输出中 				unspentOutputs[txID] = append(unspentOutputs[txID], outIdx) 				//如果累计金额大于等于要求的金额，则退出循环 				if accumulated >= amount { 					break Work 				} 			} 		} 	} 	//返回累计金额和未花费的输出 	return accumulated, unspentOutputs }  // Iterator 返回一个迭代器  func (bc *Blockchain) Iterator() *BlockchainIterator { 	//迭代器对象是一个指向区块链的指针和一个指向数据库的指针 	bci := &BlockchainIterator{bc.tip, bc.db} 	return bci }  // Next 返回区块链中的下一个区块 func (i *BlockchainIterator) Next() *Block { 	var block *Block 	//获取当前区块 	err := i.db.View(func(tx *bolt.Tx) error { 		//获取区块桶 		b := tx.Bucket([]byte(blocksBucket)) 		//获取当前区块 		encodedBlock := b.Get(i.currentHash) 		//反序列化区块 		block = DeserializeBlock(encodedBlock)  		return nil 	})  	if err != nil { 		log.Panic(err) 	} 	//更新当前区块的哈希 	i.currentHash = block.PrevBlockHash  	return block }  // dbExists 检查数据库是否存在 func dbExists() bool {  	if _, err := os.Stat(dbFile); os.IsNotExist(err) { 		return false 	}  	return true }  // NewBlockchain 创建一个新的区块 func NewBlockchain(address string) *Blockchain { 	//检查数据库是否存在 	if dbExists() == false { 		fmt.Println("No existing blockchain found. Create one first.") 		os.Exit(1) 	} 	//存储最新区块的哈希 	var tip []byte 	db, err := bolt.Open(dbFile, 0600, nil) 	if err != nil { 		log.Panic(err) 	} 	//更新数据库 	err = db.Update(func(tx *bolt.Tx) error {  		b := tx.Bucket([]byte(blocksBucket)) 		tip = b.Get([]byte("l"))  		return nil 	})  	if err != nil { 		log.Panic(err) 	} 	//创建一个区块链对象 	bc := Blockchain{tip, db}  	return &bc }  // CreateBlockchain 创建一个新的区块链 func CreateBlockchain(address string) *Blockchain { 	//检查数据库是否存在 	if dbExists() { 		fmt.Println("Blockchain already exists.") 		os.Exit(1) 	} 	var tip []byte 	//打开数据库 	db, err := bolt.Open(dbFile, 0600, nil) 	if err != nil { 		log.Panic(err) 	} 	//更新数据库 	err = db.Update(func(tx *bolt.Tx) error { 		//创建一个新的coinbase交易 		cbtx := NewCoinbaseTX(address, genesisCoinbaseData) 		//创建一个新的区块 		genesis := NewGenesisBlock(cbtx) 		//创建一个新的桶 		b, err := tx.CreateBucket([]byte(blocksBucket)) 		if err != nil { 			log.Panic(err) 		} 		//将区块存储到数据库中 		err = b.Put(genesis.Hash, genesis.Serialize()) 		if err != nil { 			log.Panic(err) 		}  		err = b.Put([]byte("l"), genesis.Hash) 		if err != nil { 			log.Panic(err) 		} 		tip = genesis.Hash  		return nil 	})  	if err != nil { 		log.Panic(err) 	}  	bc := Blockchain{tip, db}  	return &bc }  // AddBlock 将用于添加区块到区块链 func AddBlock(address string) { 	//创建一个新的区块 	bc := NewBlockchain(address) 	defer bc.db.Close() 	//创建一个新的coinbase交易 	//cbtx := NewCoinbaseTX(address, "") 	//挖掘新块并存放到数据库中 	bc.MineBlock([]*Transaction{NewCoinbaseTX(address, "")}) 	//往address地址发送奖励 	fmt.Println("Coinbase交易完成，以奖励的方式将硬币发送到地址：", address) 	fmt.Println("Success!") } 

 3.proofwork.go

这段代码实现了区块链中的工作量证明 (Proof of Work, PoW) 机制，用于确保区块链的安全性，防止恶意攻击。让我们深入理解其原理和实现：

工作量证明概述

PoW 是一种共识机制，要求节点进行一定的计算工作才能将新区块添加到区块链中。这种机制通过消耗计算资源来增加攻击成本，从而保证区块链的安全性。

代码解析

• ProofOfWork 结构体:

  • block: 指向区块的指针，包含区块头信息。
  • target: 指向一个大整数的指针，代表挖矿难度目标。哈希值必须小于该目标才算有效。

• NewProofOfWork:

  • 创建一个新的 ProofOfWork 对象，根据难度目标设置 target 值。
  • 难度目标通过 targetBits 常量控制，值越小，难度越大。

• prepareData:

  • 准备用于哈希运算的数据，包括区块头信息、随机数 nonce 等。
  • 将数据拼接成字节数组，方便进行哈希运算。

• Run:

  • 执行挖矿过程，不断尝试不同的 nonce 值，直到找到满足难度目标的哈希值。
  • 循环计算哈希值，并与 target 进行比较。
  • 如果哈希值小于 target，则挖矿成功，返回 nonce 和哈希值。
  • 否则，继续尝试下一个 nonce 值。

• Validate:

  • 验证区块的工作量证明是否有效。
  • 根据区块头信息和 nonce 计算哈希值，并与 target 比较。
  • 如果哈希值小于 target，则验证通过，返回 true。
  • 否则，验证失败，返回 false。

// -*- coding: utf-8 -*- // Time    : 2024/4/14 23:48 // Author  : blue // File    : proofwork.go // Software: Goland package main  import ( 	"bytes" 	"crypto/sha256" 	"fmt" 	"math" 	"math/big" )  var ( 	maxNonce = math.MaxInt64 )  const targetBits = 16  // ProofOfWork 包含一个指向区块的指针和一个指向big.Int的指针 type ProofOfWork struct { 	block  *Block 	target *big.Int }  // NewProofOfWork 创建并返回一个ProofOfWork结构 func NewProofOfWork(b *Block) *ProofOfWork { 	target := big.NewInt(1) 	target.Lsh(target, uint(256-targetBits))  	pow := &ProofOfWork{b, target}  	return pow }  // prepareData 准备数据 func (pow *ProofOfWork) prepareData(nonce int) []byte { 	data := bytes.Join( 		[][]byte{ 			pow.block.PrevBlockHash, 			pow.block.HashTransactions(), 			IntToHex(pow.block.Timestamp), 			IntToHex(int64(targetBits)), 			IntToHex(int64(nonce)), 		}, 		[]byte{}, 	)  	return data }  // Run 查找有效的哈希 func (pow *ProofOfWork) Run() (int, []byte) { 	var hashInt big.Int 	var hash [32]byte 	nonce := 0  	fmt.Printf("Mining a new block") 	for nonce < maxNonce { 		data := pow.prepareData(nonce)  		hash = sha256.Sum256(data) 		fmt.Printf("\r%x", hash) 		hashInt.SetBytes(hash[:])  		if hashInt.Cmp(pow.target) == -1 { 			break 		} else { 			nonce++ 		} 	} 	fmt.Print("\n\n")  	return nonce, hash[:] }  // Validate 验证工作量证明 func (pow *ProofOfWork) Validate() bool { 	var hashInt big.Int  	data := pow.prepareData(pow.block.Nonce) 	hash := sha256.Sum256(data) 	hashInt.SetBytes(hash[:])  	isValid := hashInt.Cmp(pow.target) == -1  	return isValid } 

4.Transaction.go

这段代码定义了区块链中的交易数据结构，包括交易输入、交易输出和交易本身，以及创建 coinbase 交易和普通交易的函数。让我们深入分析：

数据结构

• Transaction: 交易结构体，包含交易 ID、输入列表和输出列表。
• TXInput: 交易输入结构体，包含引用的交易 ID、输出索引和解锁脚本。
• TXOutput: 交易输出结构体，包含金额和锁定脚本。

拓展：

        在区块链技术，特别是比特币及其衍生加密货币中，交易的验证过程涉及到两个重要的概念：锁定脚本（ScriptPubKey）和解锁脚本（ScriptSig）。这两个脚本共同工作，确保只有资产的合法拥有者才能花费这些资产。在本文Transaction.go代码示例中，为了便于理解和实现，锁定脚本和解锁脚本简化为货币持有者的地址。

锁定脚本（ScriptPubKey）

// TXInput 		表示交易输入 type TXInput struct { 	Txid      []byte //引用的交易ID，表示交易的哈希 	Vout      int    //引用的输出索引 	ScriptSig string //解锁脚本 }

        在TXOutput结构体中，ScriptPubKey字段代表锁定脚本。它的作用是指定谁有权利花费这个输出中的资金。在真实的比特币系统中，ScriptPubKey可以包含更复杂的脚本，但在这个简化模型中，它被设置为接收方的地址。

解锁脚本（ScriptSig）

// TXOutput 		表示交易输出 type TXOutput struct { 	Value        int    //	输出金额 	ScriptPubKey string //锁定脚本 }

        与此同时，在TXInput结构体中，ScriptSig字段代表解锁脚本。当你尝试花费某个输出时，你需要提供一个ScriptSig，这个脚本能够"解锁"那个输出中的ScriptPubKey所施加的限制。

        在真实的比特币系统中，解锁脚本通常包含与锁定脚本相匹配的公钥和一个签名，这个签名是使用与公钥相对应的私钥生成的。这样，只有拥有正确私钥的人才能生成有效的签名，从而成功解锁输出。

简化说明

        在本文代码示例中，锁定脚本和解锁脚本被简化为直接使用地址字符串。这意味着，如果一个输出的ScriptPubKey与某个地址匹配，那么任何包含相同地址作为ScriptSig的输入都能解锁并花费这个输出。

// CanUnlockOutputWith 将检查输出是否可以使用提供的数据解锁 func (in *TXInput) CanUnlockOutputWith(unlockingData string) bool {     return in.ScriptSig == unlockingData }  // CanBeUnlockedWith 将检查输出是否可以使用提供的数据解锁 func (out *TXOutput) CanBeUnlockedWith(unlockingData string) bool {     return out.ScriptPubKey == unlockingData } 

        这种简化的实现方式有助于理解区块链交易的基本原理，即资产的转移需要通过正确的解锁条件。然而，在实际的区块链应用中，这种机制要复杂得多，涉及到密钥对和加密签名，以确保交易的安全性和用户的隐私。

函数解析

• IsCoinbase: 判断交易是否为 coinbase 交易。Coinbase 交易是区块中的第一笔交易，用于奖励矿工，其输入为空。
• SetID: 计算交易的哈希值，并将其设置为交易 ID。
• CanUnlockOutputWith: 检查交易输入的解锁脚本是否可以解锁指定的锁定脚本。
• CanBeUnlockedWith: 检查交易输出的锁定脚本是否可以被指定的解锁脚本解锁。
• NewCoinbaseTX: 创建 coinbase 交易。
  • 输入为空，输出为指定地址和奖励金额。
  • 设置交易 ID。
• NewUTXOTransaction: 创建普通交易。
  • 根据发送方地址和转账金额，查找满足条件的未花费交易输出 (UTXO)。
  • 如果 UTXO 余额不足，则报错。
  • 否则，构建交易输入和输出列表。
  • 如果 UTXO 余额大于转账金额，则创建找零输出。
  • 设置交易 ID。
•  IntToHex 将整数转换为字节数组。

// -*- coding: utf-8 -*- // Time    : 2024/4/15 22:16 // Author  : blue // File    : Transaction.go // Software: Goland package main  import ( 	"bytes" 	"crypto/sha256" 	"encoding/gob" 	"encoding/hex" 	"fmt" 	"log" )  // 表示每个区块链的奖励 const subsidy = 10  // Transaction 	表示一笔交易 type Transaction struct { 	ID   []byte     //交易ID，表示交易的哈希 	Vin  []TXInput  //交易输入 	Vout []TXOutput //交易输出 }  // TXInput 		表示交易输入 type TXInput struct { 	Txid      []byte //引用的交易ID，表示交易的哈希 	Vout      int    //引用的输出索引 	ScriptSig string //解锁脚本 }  // TXOutput 		表示交易输出 type TXOutput struct { 	Value        int    //	输出金额 	ScriptPubKey string //锁定脚本 }  // IsCoinbase 将检查交易是否为coinbase交易 func (tx Transaction) IsCoinbase() bool { 	return len(tx.Vin) == 1 && len(tx.Vin[0].Txid) == 0 && tx.Vin[0].Vout == -1 }  // SetID 将设置交易ID，交易ID是交易的哈希 func (tx *Transaction) SetID() { 	//创建一个缓冲区 	var encoded bytes.Buffer 	//创建一个哈希 	var hash [32]byte 	//创建一个编码器 	enc := gob.NewEncoder(&encoded) 	//编码 	err := enc.Encode(tx)  	if err != nil { 		log.Panic(err) 	} 	//计算哈希 	hash = sha256.Sum256(encoded.Bytes()) 	//设置ID 	tx.ID = hash[:] }  // CanUnlockOutputWith 将检查输出是否可以使用提供的数据解锁 func (in *TXInput) CanUnlockOutputWith(unlockingData string) bool { 	return in.ScriptSig == unlockingData }  // CanBeUnlockedWith 将检查输出是否可以使用提供的数据解锁 func (out *TXOutput) CanBeUnlockedWith(unlockingData string) bool { 	return out.ScriptPubKey == unlockingData }  // NewCoinbaseTX 将创建一个新的coinbase交易 func NewCoinbaseTX(to, data string) *Transaction { 	// 如果没有数据，则使用默认数据 	if data == "" { 		data = fmt.Sprintf("Reward to '%s'", to) 	} 	//coinbase交易没有输入，所以Txid为空，Vout为-1 	txin := TXInput{[]byte{}, -1, data} 	//创建一个输出 	txout := TXOutput{subsidy, to} 	//创建一个交易 	tx := Transaction{nil, []TXInput{txin}, []TXOutput{txout}} 	tx.SetID()  	return &tx }  // NewUTXOTransaction 将创建一个新的UTXO交易 func NewUTXOTransaction(from, to string, amount int, bc *Blockchain) *Transaction { 	var inputs []TXInput 	var outputs []TXOutput 	//获取未花费的输出 	acc, validOutputs := bc.FindSpendableOutputs(from, amount) 	//检查余额是否足够 	if acc < amount { 		log.Panic("ERROR: Not enough funds") 	} 	//	构建一个输入列表 	for txid, outs := range validOutputs { 		//将交易ID转换为字节数组 		txID, err := hex.DecodeString(txid) 		if err != nil { 			log.Panic(err) 		} 		//遍历输出 		for _, out := range outs { 			//创建一个输入 			input := TXInput{txID, out, from} 			//添加到输入列表 			inputs = append(inputs, input) 		} 	}  	//创建一个输出 	outputs = append(outputs, TXOutput{amount, to}) 	//如果余额大于转账金额，则创建一个找零 	if acc > amount { 		outputs = append(outputs, TXOutput{acc - amount, from}) // a change 	} 	//创建一个交易 	tx := Transaction{nil, inputs, outputs} 	tx.SetID()  	return &tx }  // IntToHex 将整数转换为字节数组 func IntToHex(num int64) []byte { 	buff := new(bytes.Buffer) 	err := binary.Write(buff, binary.BigEndian, num) 	if err != nil { 		log.Panic(err) 	}  	return buff.Bytes() } 

5.cli.go

这段代码实现了一个简单的命令行界面 (CLI)，用于与区块链进行交互，包括创建区块链、查询余额、打印区块链和发送交易等功能。让我们逐一解析：

CLI 结构体

• CLI 结构体用于处理命令行参数和执行相应操作。

函数解析

• createBlockchain: 创建新的区块链，并将创世区块奖励发送到指定地址。
• getBalance: 查询指定地址的余额。
• printUsage: 打印命令行用法帮助信息。
• validateArgs: 验证命令行参数是否合法。
• printChain: 打印整个区块链的信息，包括每个区块的哈希、时间戳、交易等。
• send: 从一个地址向另一个地址发送指定数量的币。
• run: 运行命令行界面，循环提示用户输入命令，并根据命令执行相应操作。
• addBlock: 添加新区块到区块链。

// -*- coding: utf-8 -*- // Time    : 2024/4/15 22:18 // Author  : blue // File    : cli.go // Software: Goland package main  import ( 	"fmt" 	"os" 	"strconv" 	"time" )  // CLI 处理命令行参数 type CLI struct { }  // createBlockchain 创建区块链 func (cli *CLI) createBlockchain(address string) { 	// 创建区块链 	bc := CreateBlockchain(address) 	bc.db.Close() 	fmt.Println("Done!") }  // getBalance 获取地址的余额 func (cli *CLI) getBalance(address string) { 	// 创建区块链 	bc := NewBlockchain(address) 	defer bc.db.Close() 	balance := 0 	// 获取地址的UTXO 	UTXOs := bc.FindUTXO(address) 	// 计算余额 	for _, out := range UTXOs { 		balance += out.Value 	}  	fmt.Printf("Balance of '%s': %d\n", address, balance) }  // printUsage 打印用法 func (cli *CLI) printUsage() { 	fmt.Println("Usage:") 	fmt.Println(" English： getbalance -address ADDRESS - Get balance of ADDRESS、、、中文：getbalance - address ADDRESS -获取地址的余额") 	fmt.Println("  createblockchain -address ADDRESS - Create a blockchain and send genesis block reward to ADDRESS") 	fmt.Println("  printchain - Print all the blocks of the blockchain") 	fmt.Println("  send -from FROM -to TO -amount AMOUNT - Send AMOUNT of coins from FROM address to TO") }  // validateArgs 验证参数 func (cli *CLI) validateArgs() { 	// 验证参数 	if len(os.Args) < 2 { //什么意思：如果命令行参数少于2个 		// 打印用法 		cli.printUsage() 		os.Exit(1) //什么意思：退出 	} }  // printChain 打印区块链 func (cli *CLI) printChain() { 	// 创建区块链 	bc := NewBlockchain("") 	defer bc.db.Close() 	// 创建迭代器 	bci := bc.Iterator() 	// 循环打印区块链中的区块 	for { 		block := bci.Next() 		fmt.Println("=========================================") 		//把时间戳转换为时间 		timeFormat := time.Unix(block.Timestamp, 0) 		fmt.Println("timestamp:", timeFormat) 		fmt.Printf("PrevBlockHash: %x\n", block.PrevBlockHash) 		fmt.Printf("BlockHash: %x\n", block.Hash) 		//显示完整的交易信息 		fmt.Println("Transactions:") 		for _, tx := range block.Transactions { 			//显示交易ID 			//fmt.Printf("Transaction ID: %x\n", tx.ID) 			var str string 			for _, value := range tx.ID { 				str += strconv.Itoa(int(value)) 			} 			fmt.Println("Transaction ID: " + str) 			fmt.Println("TXInput:") 			for _, tx := range tx.Vin { 				fmt.Println(tx.Txid) 				fmt.Println(tx.Vout) 				fmt.Println(tx.ScriptSig)  			} 			fmt.Println("TXOutputs:") 			for _, tx := range tx.Vout { 				fmt.Println(tx.Value) 				fmt.Println(tx.ScriptPubKey) 			} 		} 		//fmt.Println("Transactions:", block.Transactions) 		fmt.Printf("Nonce: %d\n", block.Nonce) 		pow := NewProofOfWork(block) 		fmt.Printf("PoW: %s\n", strconv.FormatBool(pow.Validate())) 		fmt.Println()  		if len(block.PrevBlockHash) == 0 { 			break 		} 	} }  // send 发送 func (cli *CLI) send(from, to string, amount int) { 	bc := NewBlockchain(from) 	defer bc.db.Close() 	// 创建交易 	tx := NewUTXOTransaction(from, to, amount, bc) 	// 挖矿 	bc.MineBlock([]*Transaction{tx}) 	fmt.Println("Success!") }  // 新建一个run函数，实现在程序框显示功能，并给出提示，然后根据相应的命令执行相应的操作 func (cli *CLI) run() { 	for { 		fmt.Println("1. getbalance -address ADDRESS - 获取地址的余额 ") 		fmt.Println("2. createblockchain -address ADDRESS - 创建区块链并将创世区块奖励发送到ADDRESS") 		fmt.Println("3. printchain - 打印区块链") 		fmt.Println("4. send -from FROM -to TO -amount AMOUNT - 从FROM地址向TO发送AMOUNT硬币") 		fmt.Println("5. mine ADDRESS挖矿创建区块链并将创世区块奖励发送到ADDRESS") 		fmt.Println("6. exit - Exit") 		fmt.Println("Please enter the command:") 		var cmd string 		fmt.Scanln(&cmd) 		switch cmd { 		case "1": 			fmt.Println("Please enter the address:") 			var address string 			fmt.Scanln(&address) 			cli.getBalance(address) 			fmt.Println() 		case "2": 			fmt.Println("Please enter the address:") 			var address string 			fmt.Scanln(&address) 			cli.createBlockchain(address) 			fmt.Println() 		case "3": 			cli.printChain() 		case "4": 			fmt.Println("Please enter the from address:") 			var from string 			fmt.Scanln(&from) 			fmt.Println("Please enter the to address:") 			var to string 			fmt.Scanln(&to) 			fmt.Println("Please enter the amount:") 			var amount int 			fmt.Scanln(&amount) 			cli.send(from, to, amount) 			fmt.Println() 		case "5": 			fmt.Println("Please enter the address:") 			var address string 			fmt.Scanln(&address) 			//我们要创建新区块 			//挖掘新区块 			//AddBlock(address) 			cli.addBlock(address) 			fmt.Println() 		case "6": 			os.Exit(0) 		default: 			fmt.Println("Invalid command") 		} 	} }  // addBlock 添加区块 func (cli *CLI) addBlock(address string) { 	// 创建区块链 	AddBlock(address) } 

6.main.go

这段代码是整个区块链项目的入口，它创建了一个 CLI 对象，并调用其 run 方法启动命令行界面。

• main 函数: 程序的入口函数。
• cli := CLI{}: 创建一个 CLI 对象，用于处理命令行参数和执行相应操作。
• cli.run(): 调用 CLI 对象的 run 方法，启动命令行界面，并开始与用户交互。

// -*- coding: utf-8 -*- // Time    : 2024/4/15 22:15 // Author  : blue // File    : main.go // Software: Goland package main  func main() { 	cli := CLI{} 	//cli.Run() 	cli.run() } 

总结

      通过本篇博客，我们详细探讨了如何使用Go语言实现一个简易的区块链系统。我们从区块的数据结构出发，探讨了区块链的创建、交易的处理、工作量证明算法的实现，以及通过CLI与区块链进行交互的方法。此外，我们还了解了如何使用BoltDB对区块链数据进行持久化存储，这对于保证区块链数据的持久性和可靠性至关重要。

        实现一个区块链系统虽然复杂，但通过逐步分析和实现，我们可以更好地理解其背后的原理和技术。希望这篇博客能为那些对区块链技术感兴趣的读者提供一定的帮助，并激发大家进一步探索和实践区块链技术的热情。