（1）定义钱包结构体
type Wallet struct {
PrivateKey ecdsa.PrivateKey // 私钥
PublicKey []byte // 保存了公钥的X和Y
}由于不想在交易中传递公钥本身，提供公钥在网络上的传输效率，所以我们将公钥拆分成两个[]byte变量，然后将他们拼接成一个[]byte后存放在公钥字段中。
在verify之前一直把这个拼接的byte数组当成公钥，在verifty时将它再拆成X, Y 两个big.Int 类型的数据，然后拼装成真实的公钥。
（2）创建钱包
// 创建方法
func NewWallet() *Wallet {
privateKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
panic("ecdsa.GenerateKey err!")
}
publicKeyOrigin := privateKey.PublicKey
publicKey := append(publicKeyOrigin.X.Bytes(), publicKeyOrigin.Y.Bytes()...)
return &Wallet{*privateKey, publicKey}
}（3）修改Run方法，添加case newWallet条件判断。
func (cli *Cli) Run() {
args := os.Args
if len(args) < 2 {
fmt.Println(Usage)
return
}
// 获取命令名称
command := args[1]
switch command {
...
...
case "newWallet":
cli.CreateWallet()
default:
fmt.Println(Usage)
}
}（4）添加CreateWallet函数
// 创建钱包
func (cli *Cli) CreateWallet() {
wallet := NewWallet()
fmt.Printf("private key : %x\n", wallet.PrivateKey)
fmt.Printf("public key : %x\n", wallet.PublicKey)
}二、生成地址
（1）定义GetAddress函数
// 生成钱包地址
func (wallet Wallet) GetAddress() string {
// 创建公钥哈希
publicKeyBytes := sha256.Sum256(wallet.PublicKey)
ripemd := ripemd160.New()
_, err := ripemd.Write(publicKeyBytes[:])
if err != nil {
panic("ripemd.Write err!")
}
publicKeyHash := ripemd.Sum(nil)
// 创建payload
payload := append([]byte{00}, publicKeyHash...)
// 创建checkSum
hash1 := sha256.Sum256(payload)
checkSum := sha256.Sum256(hash1[:])
// 创建checkCode
checkCode := append(payload, checkSum[:4]...)
// 生成address
address := base58.Encode(checkCode)
return address
}（2）修改CreateWallet函数，打印地址。
// 创建钱包
func (cli *Cli) CreateWallet() {
wallet := NewWallet()
fmt.Printf("private key : %x\n", wallet.PrivateKey)
fmt.Printf("public key : %x\n", wallet.PublicKey)
fmt.Printf("address : %s\n", wallet.GetAddress())
}三、创建钱包容器
比特币客户端可以生成无数多个秘钥对，将它们持久化，保存在一个wallets.bat文件中。
（1）定义钱包容器
type Wallets struct {
Wallets map[string]*Wallet
}（2）提供创建方法
// 创建方法
func NewWallets() *Wallets {
var ws Wallets
ws.Wallets = make(map[string]*Wallet)
return &ws
}（3）创建钱包
// 创建钱包
func (ws *Wallets) CreateWallet() string {
wallet := NewWallet()
address := wallet.GetAddress()
ws.Wallets[address] = wallet
return address
}（4）修改Cli对象的CreateWallet方法
// 创建钱包
func (cli *Cli) CreateWallet() {
/*wallet := NewWallet()
fmt.Printf("private key : %x\n", wallet.PrivateKey)
fmt.Printf("public key : %x\n", wallet.PublicKey)
fmt.Printf("address : %s\n", wallet.GetAddress())*/
ws := NewWallets()
address := ws.CreateWallet()
fmt.Printf("address : %s\n", address)
}（5）保存钱包到本地
// 保存钱包数据到本地
func (ws *Wallets) SaveWallets() {
// 1.对Wallets加密
var buffer bytes.Buffer
// 注册接口类型, 否则会出现“gob: type not registered for interface: elliptic.p256Curve”
gob.Register(elliptic.P256())
encoder := gob.NewEncoder(&buffer)
err := encoder.Encode(&ws)
if err != nil {
panic(err)
}
// 2.把加密后数据写入文件中
err = ioutil.WriteFile(walletFile, buffer.Bytes(), 0644)
if err != nil {
panic("ioutil.WriteFile err!")
}
}注意：如果Encode/Decode类型是interface或者struct中某些字段是interface{}的时候，需要在gob中注册interface。
（6）修改CreateWallet函数，调用SaveWallets方法。
// 创建钱包
func (ws *Wallets) CreateWallet() string {
wallet := NewWallet()
address := wallet.GetAddress()
ws.Wallets[address] = wallet
// 保存钱包到本地
ws.SaveWallets()
return address
}（7）从本地加载钱包
// 从本地读取钱包数据
func (ws *Wallets) LoadWallets() {
// 1.校验钱包文件是否存在
_, err := os.Stat(walletFile)
if os.IsNotExist(err) {
return
}
// 2.读取文件数据
data, err := ioutil.ReadFile(walletFile)
if err != nil {
panic("ioutil.ReadFile err!")
}
// 3.解密
gob.Register(elliptic.P256())
decoder := gob.NewDecoder(bytes.NewReader(data))
var wallets Wallets
err = decoder.Decode(&wallets)
if err != nil {
panic(err)
}
// 4.把数据设置到wallets的Wallets字段
ws.Wallets = wallets.Wallets
}（8）修改NewWallets函数，调用LoadWallets方法。
// 创建方法
func NewWallets() *Wallets {
var ws Wallets
ws.Wallets = make(map[string]*Wallet)
ws.LoadWallets()
return &ws
}（9）获取所有地址
// 获取所有地址
func (ws *Wallets) GetAllAddress() []string {
var addresses []string
for address := range ws.Wallets {
addresses = append(addresses, address)
}
return addresses
}（10）添加命令
// 列出所有钱包地址
func (cli *Cli) ListAddress() {
ws := NewWallets()
addresses := ws.GetAllAddress()
for _, addr := range addresses {
fmt.Printf("地址：%s\n", addr)
}
}（11）修改Run函数，添加case listAddress条件判断。
func (cli *Cli) Run() {
args := os.Args
if len(args) < 2 {
fmt.Println(Usage)
return
}
// 获取命令名称
command := args[1]
switch command {
...
...
case "listAddresses":
cli.ListAddress()
default:
fmt.Println(Usage)
}
}四、修改交易结构
（1）修改TXInput和TXOutput字段。
type TXInput struct {
TXID []byte // 引用输出的交易ID
OutputIndex int64 // 引用输出的索引
//ScriptSig string // 解锁脚本（实际上这里应该是签名和公钥）
Signature []byte // 签名
PubKey []byte // 公钥
}
type TXOutput struct {
Value float64 // 金额
//ScriptPubKey string // 锁定脚本（公钥哈希）
PubKeyHash []byte // 公钥哈希
}（2）创建锁定脚本
// 锁定脚本(设置output的公钥哈希)
func (output *TXOutput) Lock(address string) {
// 1.使用base58加密，得到checkCode
checkCode := base58.Decode(address)
// 2.截取字节数组，去掉左边1位，右边4位
publicKeyHash := checkCode[1 : len(checkCode)-4]
// 3.设置公钥哈希
output.PubKeyHash = publicKeyHash
}（3）提供NewTXOuptput函数
// 创建Output
// 参数一：接收金额
// 参数二：接收帐号地址
func NewTXOutput(value float64, address string) *TXOutput {
output := TXOutput{
Value: value,
}
output.Lock(address)
return &output
}（4）修改NewCoinBase函数，使用NewTXOutput方法创建output对象。
// 创建挖矿交易
// 参数一：矿工地址
// 参数二：矿工附加信息
func NewCoinBaseTx(address string, data string) *Transaction {
input := TXInput{nil, -1, nil, []byte(data)}
//output := TXOutput{reward, address}
output := NewTXOutput(reward, address)
tx := Transaction{nil, []TXInput{input}, []TXOutput{*output}}
tx.SetHash()
return &tx
}（5）修改NewTransaction函数。
创建新的交易一定是要使用钱包里面的公钥私钥，具体步骤：
1）打开钱包，根据创建人的address找到对应的钱包；
2）查找可用的utxo，注意此时传递的不再是地址，而是地址的公钥哈希；
3）创建输入和输出；
4）使用私钥对交易进行签名；
// 创建交易
func NewTransaction(from, to string, amount float64, bc *BlockChain) *Transaction {
// 创建Wallets
ws := NewWallets()
// 获取转账人的钱包
wallet := ws.Wallets[from]
if wallet == nil {
fmt.Printf("本地没有 %s 的钱包，无法创建交易\n", from)
return nil
}
pubKey := wallet.PublicKey
//priKey := wallet.PrivateKey // 签名时候用到
// 解析公钥，得到公钥哈希
pubKeyHash := HashPubKey(pubKey)
// 1.找到最优的utxos
utxos, total := bc.FindNeedUTXOs(pubKeyHash, amount)
// 2.检查余额是否足够
if total < amount {
fmt.Println("余额不足！")
return nil
}
// 3.如果余额足够，那么创建新的区块
var inputs []TXInput
var outputs []TXOutput
for txId, outputIndexs := range utxos {
for _, outputIndex := range outputIndexs {
input := TXInput{[]byte(txId), outputIndex, nil, pubKey}
inputs = append(inputs, input)
}
}
//output := TXOutput{amount, to}
output := NewTXOutput(amount, to)
outputs = append(outputs, *output)
// 找零
if total > amount {
//output = TXOutput{total - amount, from}
output = NewTXOutput(total-amount, from)
outputs = append(outputs, *output)
}
// 4.创建Transaction
tx := Transaction{nil, inputs, outputs}
tx.SetHash()
return &tx
}（6）提供HashPubKey函数
// 从公钥生成公钥哈希
func HashPubKey(pubKey []byte) []byte {
hash := sha256.Sum256(pubKey)
ripemd160 := ripemd160.New()
_, err := ripemd160.Write(hash[:])
if err != nil {
panic("ripemd160.Write err!")
}
publicKeyHash := ripemd160.Sum(nil)
return publicKeyHash
}（7）修改FindNeedUTXOs函数，把参数address替换成pubKeyHash。
// 查找最合理的utxo
func (bc *BlockChain) FindNeedUTXOs(pubKeyHash []byte, amount float64) (map[string][]int64, float64) {
txs := bc.FindUTXOTransaction(pubKeyHash)
needUTXOs := make(map[string][]int64) // 保存最合理的utxo
var total float64 // 最合理utxo的总金额
OUTPUT_TAG:
for _, tx := range txs {
for i, output := range tx.Outputs {
//if output.ScriptPubKey == address {
if bytes.Equal(output.PubKeyHash, pubKeyHash) {
if total < amount {
total += output.Value
needUTXOs[string(tx.TXID)] = append(needUTXOs[string(tx.TXID)], int64(i))
} else {
break OUTPUT_TAG
}
}
}
}
return needUTXOs, total
}（8）修改FindUTXOTransaction函数，把参数address替换成pubKeyHash。
// 查询所有UTXO交易
// 参数：账户地址
func (bc *BlockChain) FindUTXOTransaction(pubKeyHash []byte) []Transaction {
var txs []Transaction
spentUTXOs := make(map[string][]int64) // 已消费的UTXO, Key代表交易地址，Value为引用output的索引
// 遍历所有区块
itr := bc.NewIterator()
for {
block := itr.Prev()
// 遍历交易
for _, tx := range block.Data {
// 遍历output
OUTPUT_TAG:
for i, output := range tx.Outputs {
if spentUTXOs[string(tx.TXID)] != nil {
// 获取消费过的utxo的索引
indexs := spentUTXOs[string(tx.TXID)]
// 循环比较当前output的索引是否在indexs中存在，如果存在就代表该output已经被消费
for _, index := range indexs {
if index == int64(i) {
continue OUTPUT_TAG
}
}
}
// 如果output的ScriptPubKey等于address，代表该output是属于adddres指定的账户
//if output.ScriptPubKey == address {
if bytes.Equal(output.PubKeyHash, pubKeyHash) {
txs = append(txs, *tx)
}
}
// 遍历input
if !tx.isCoinBase() {
for _, input := range tx.Inputs {
// 如果input的ScriptSig等于address，就代表该input是属于指定address的账户
//if input.ScriptSig == address {
if bytes.Equal(HashPubKey(input.PubKey), pubKeyHash) {
spentUTXOs[string(input.TXID)] = append(spentUTXOs[string(input.TXID)], int64(input.OutputIndex))
}
}
}
}
if (len(block.PrevHash) == 0) {
return txs
}
}
}（9）修改FindUTXOs函数，把参数address替换成pubKeyHash。
// 查找所有的utxo
func (bc *BlockChain) FindUTXOs(pubKeyHash []byte) []TXOutput {
txs := bc.FindUTXOTransaction(pubKeyHash)
var outputs []TXOutput
// 遍历所有utxos交易
for _, tx := range txs {
// 遍历utxo交易的所有output
for _, output := range tx.Outputs {
// 如果output的ScriptPubKey等于address，就代表该output是我们要找到output
//if output.ScriptPubKey == address {
if bytes.Equal(output.PubKeyHash, pubKeyHash) {
outputs = append(outputs, output)
}
}
}
return outputs
}（10）修改GetBalance函数，根据address反推出公钥哈希。
// 查询余额
func (cli *Cli) GetBalance(address string) {
isOk := checkAddress(address)
if !isOk {
fmt.Println("地址无效")
return
}
// 由地址反推出公钥哈希
checkCode := base58.Decode(address)
pubKeyHash := checkCode[1: len(checkCode)-4]
// 查询所有未消费的output
utxos := cli.bc.FindUTXOs(pubKeyHash)
var total float64
for _, output := range utxos {
total += output.Value
}
fmt.Printf("%s的余额: %f\n", address, total)
}（11）定义checkAddress函数，校验地址有效性。
// 校验地址
func checkAddress(address string) bool {
checkCode := base58.Decode(address)
// 获取payload
payload := checkCode[:len(checkCode)-4]
// 获取checkSum
checkSum := checkCode[len(checkCode)-4:]
// 对payload执行两次sha256运算，得到新的checkSum
hash := sha256.Sum256(payload)
targetCheckSum := sha256.Sum256(hash[:])
// 比较两个checkSum是否相等，如果相等代表地址有效
return bytes.Equal(checkSum, targetCheckSum[:4])
}五、数字签名和认证
1. 功能描述
签名需要什么？1）想要签名的数据；2）私钥；
验证需要什么？2）想要签名的数据；2）签名；3）公钥；
签名数据应该包含：
1）欲使用utxo中的pubKeyHash（付款人）；
2）新生成utxo中的pubKeyHash（收款人）；
3）转账金额
最后，把签好的数据放在每一个input的sig中。
由于每一笔交易都可能引用多个utxo（存在于多条交易中），所以我们要遍历所有的引用交易，并对它们逐个签名。
什么时候签名？
交易创建完成之后，在写入区块之前，我们要对其进行签名。
什么时候验证？矿工挖矿前先进行验证。
2. 功能实现
（1）添加Sign函数
为了便于我们遍历账本，签名函数由Transaction提供，但是签名动作由blockChain来实现，最后在SignTransaction内部调用Sign函数。
// 签名
// 参数一：私钥
// 参数二：要签名的交易
func (tx *Transaction) Sign(priKey *ecdsa.PrivateKey, prevTXs map[string]Transaction) {
if tx.isCoinBase() {
return
}
// 1.把tx的副本，然后把input中的Signature和PublicKey字段置空
// 2.遍历txCopy中的所有inputs，然后得到引用output的公钥哈希,并保存在input的PublicKey中
// 3.为txCopy生成Id值(当前input所引用output的公钥哈希+outputs)，该txId就是我们要签名的最终数据
// 4.执行签名动作，得到r和s
// 5.把r和s进行拼接，然后放入到我们所签名的input的Signature字段中
txCopy := tx.TrimmedCopy()
for i, input := range txCopy.Inputs {
prevTx := prevTXs[string(input.TXID)]
if len(prevTx.TXID) == 0 {
panic("引用交易无效")
}
output := prevTx.Outputs[input.OutputIndex]
txCopy.Inputs[i].PubKey = output.PubKeyHash
txCopy.SetHash()
txCopy.Inputs[i].PubKey = nil
// 得到签名数据
signData := txCopy.TXID
r, s, err := ecdsa.Sign(rand.Reader, priKey, signData)
if err != nil {
panic(err)
}
signature := append(r.Bytes(), s.Bytes()...)
tx.Inputs[i].Signature = signature
}
}（2）定义TrimmedCopy函数，该函数用于创建交易的副本，但是input的签名和公钥先置空。
func (tx *Transaction) TrimmedCopy() Transaction {
var inputs []TXInput
var outputs []TXOutput
// 赋值inputs
for _, input := range tx.Inputs {
// 1.构建一个新的input，该input与遍历出来的input相同，但是Signature和PublicKey字段留空
// 2.把新的input添加到inputs集合中
inputs = append(inputs, TXInput{input.TXID, input.OutputIndex, nil, nil})
}
// 复制outputs
for _, output := range tx.Outputs {
outputs = append(outputs, output)
}
return Transaction{tx.TXID, inputs, outputs}
}（3）定义SignTransaction函数
// 对交易添加签名
// 注意：需要对每一个input都要添加签名
// 签名所需：私钥 + 数据
func (bc *BlockChain) SignTransaction(tx Transaction, priKey ecdsa.PrivateKey) {
// Key为交易Id, Value为对应的交易
prevTXs := make(map[string]Transaction)
// 遍历所有input，找出所有input对应的交易
for _, input := range tx.Inputs {
// 根据交易ID查找Transaction
prevTX, err := bc.FindTransaction(input.TXID)
if err != nil {
panic(err)
}
prevTXs[string(input.TXID)] = prevTX
}
// 签名
tx.Sign(&priKey, prevTXs)
}（4）定义FindTransaction函数
// 根据交易ID查找
func (bc *BlockChain) FindTransaction(txId []byte) (Transaction, error) {
itr := bc.NewIterator()
for {
block := itr.Prev()
for _, tx := range block.Data {
if bytes.Equal(tx.TXID, txId) {
return *tx, nil
}
}
if len(block.PrevHash) == 0 {
break
}
}
return Transaction{}, errors.New("Transactioin not found")
}（5）修改NewTransaction函数，调用SignTransaction方法进行数字签名。
// 创建交易
func NewTransaction(from, to string, amount float64, bc *BlockChain) *Transaction {
// 创建Wallets
ws := NewWallets()
// 获取转账人的钱包
wallet := ws.Wallets[from]
if wallet == nil {
fmt.Printf("本地没有 %s 的钱包，无法创建交易\n", from)
return nil
}
pubKey := wallet.PublicKey
priKey := wallet.PrivateKey // 签名时候用到
.....
// 5. 签名
bc.SignTransaction(tx, priKey)
return &tx
}（6）添加认证函数
// 校验
func (bc *BlockChain) VerifyTransaction(tx *Transaction) bool {
if tx.isCoinBase() {
return true
}
prevTXs := make(map[string]Transaction)
for _, input := range tx.Inputs {
prevTX, err := bc.FindTransaction(input.TXID)
if err != nil {
log.Panic(err)
}
prevTXs[string(prevTX.TXID)] = prevTX
}
return tx.Verify(prevTXs)
}（7）定义Verify函数
// 校验
func (tx *Transaction) Verify(prevTXs map[string]Transaction) bool {
if tx.isCoinBase() {
return true
}
// 1.准备校验数据
txCopy := tx.TrimmedCopy()
for i, input := range tx.Inputs {
// 根据input的txid找到前交易
prevTx := prevTXs[string(input.TXID)]
if len(prevTx.TXID) == 0 {
panic("引用交易无效!")
}
// 得到input所引用output的公钥哈希，并设置到txCopy的input的PublicKey字段中
txCopy.Inputs[i].PubKey = prevTx.Outputs[input.OutputIndex].PubKeyHash
// 生成ID
txCopy.SetHash()
// 校验数据
data := txCopy.TXID
// 2.得到Signature，然后拆分出r和s
signature := input.Signature
r := big.Int{}
s := big.Int{}
r.SetBytes(signature[:len(signature)/2])
s.SetBytes(signature[len(signature)/2:])
// 3.得到公钥，然后拆分出x和y
pubKey := input.PubKey
x := big.Int{}
y := big.Int{}
x.SetBytes(pubKey[:len(pubKey)/2])
y.SetBytes(pubKey[len(pubKey)/2:])
// 构建一个原生的publicKey
publicKeyOrigin := ecdsa.PublicKey{elliptic.P256(), &x, &y}
// 4.Verify
isOk := ecdsa.Verify(&publicKeyOrigin, data, &r, &s)
if !isOk {
return false
}
}
return true
}（7）修改AddBlock函数
当一笔交易发送到对端时，接收方在打包到自己的区块前，需要先对交易进行校验，从而保证
1.持有者花费的确实是自己的钱
2.交易确实是由私钥的持有者发起的
func (bc *BlockChain) AddBlock(txs []*Transaction) {
// 校验交易（每个交易都需要校验）
for _, tx := range txs {
isOk := bc.VerifyTransaction(tx)
if !isOk {
fmt.Println("矿工发现无效交易！")
return
}
}
// 获取最后区块hash
lastHash := bc.Tail
// 创建区块
//block := NewBlock([]byte(data), lastHash)
block := NewBlock(txs, lastHash)
// 更新操作
bc.Db.Update(func(tx *bolt.Tx) error {
bucket := tx.Bucket([]byte(bucketName))
if bucket == nil {
panic("bucket should not be nil!")
}
// 向bolt数据库添加新区块
bucket.Put(block.Hash, block.Serialize())
// 更新数据库的last
bucket.Put([]byte(last), block.Hash)
// 更新bc.Tail
bc.Tail = block.Hash
return nil
})
}（8）添加打印命令
func (tx Transaction) String() string {
var lines []string
lines = append(lines, fmt.Sprintf("--- Transaction %x:", tx.TXID))
for i, input := range tx.Inputs {
lines = append(lines, fmt.Sprintf(" Input %d:", i))
lines = append(lines, fmt.Sprintf(" TXID: %x", input.TXID))
lines = append(lines, fmt.Sprintf(" Out: %d", input.OutputIndex))
lines = append(lines, fmt.Sprintf(" Signature: %x", input.Signature))
lines = append(lines, fmt.Sprintf(" PubKey: %x", input.PubKey))
}
for i, output := range tx.Outputs {
lines = append(lines, fmt.Sprintf(" Output %d:", i))
lines = append(lines, fmt.Sprintf(" Value: %f", output.Value))
lines = append(lines, fmt.Sprintf(" Script: %x", output.PubKeyHash))
}
return strings.Join(lines, "\n")
}