第一章：比特币原理与实现

package main

import (
    "bytes"
    "crypto/sha256"
    "encoding/gob"
    "encoding/hex"
    "fmt"
    "log"
    "math"
    "math/big"
    "time"
)

// 区块结构
type Block struct {
    Timestamp     int64          // 时间戳
    Transactions  []*Transaction // 交易列表
    PrevBlockHash []byte         // 前一个区块哈希
    Hash          []byte         // 当前区块哈希
    Nonce         int            // 工作量证明随机数
    Height        int            // 区块高度
}

// 区块链结构
type Blockchain struct {
    tip []byte   // 最新区块的哈希
    db  *DB      // 数据库接口
}

// 交易输入
type TXInput struct {
    Txid      []byte // 引用的交易ID
    Vout      int    // 引用的输出索引
    Signature []byte // 签名
    PubKey    []byte // 公钥
}

// 交易输出
type TXOutput struct {
    Value      int    // 金额（聪）
    PubKeyHash []byte // 公钥哈希
}

// 交易
type Transaction struct {
    ID   []byte     // 交易ID
    Vin  []TXInput  // 输入列表
    Vout []TXOutput // 输出列表
}

// UTXO集合
type UTXOSet struct {
    Blockchain *Blockchain
}

// 常量定义
const (
    targetBits       = 16                // 挖矿难度（前导零的位数）
    maxNonce         = math.MaxInt64     // 最大Nonce值
    blockReward      = 50                // 区块奖励（BTC）
    version          = byte(0x00)        // 地址版本
    addressChecksumLen = 4               // 地址校验和长度
)

// 工作量证明结构
type ProofOfWork struct {
    block  *Block
    target *big.Int // 难度目标
}

// 创建工作量证明
func NewProofOfWork(b *Block) *ProofOfWork {
    target := big.NewInt(1)
    target.Lsh(target, uint(256-targetBits)) // 左移，设置难度

    pow := &ProofOfWork{b, target}
    return pow
}

// 准备数据进行哈希
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
}

// 执行工作量证明（挖矿）
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)

        if math.Remainder(float64(nonce), 100000) == 0 {
            fmt.Printf("\r%x", hash)
        }

        hashInt.SetBytes(hash[:])

        // 检查哈希是否小于目标值
        if hashInt.Cmp(pow.target) == -1 {
            fmt.Printf("\r%x\n", hash)
            break
        } else {
            nonce++
        }
    }
    fmt.Print("\n\n")

    return nonce, hash[:]
}

// 验证工作量证明
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
}

// 计算区块内所有交易的哈希（Merkle Root）
func (b *Block) HashTransactions() []byte {
    var transactions [][]byte

    for _, tx := range b.Transactions {
        transactions = append(transactions, tx.Serialize())
    }
    mTree := NewMerkleTree(transactions)

    return mTree.RootNode.Data
}

// Merkle树节点
type MerkleNode struct {
    Left  *MerkleNode
    Right *MerkleNode
    Data  []byte
}

// Merkle树
type MerkleTree struct {
    RootNode *MerkleNode
}

// 创建Merkle节点
func NewMerkleNode(left, right *MerkleNode, data []byte) *MerkleNode {
    mNode := MerkleNode{}

    if left == nil && right == nil {
        // 叶子节点
        hash := sha256.Sum256(data)
        mNode.Data = hash[:]
    } else {
        // 中间节点
        prevHashes := append(left.Data, right.Data...)
        hash := sha256.Sum256(prevHashes)
        mNode.Data = hash[:]
    }

    mNode.Left = left
    mNode.Right = right

    return &mNode
}

// 创建Merkle树
func NewMerkleTree(data [][]byte) *MerkleTree {
    var nodes []MerkleNode

    // 如果交易数量为奇数，复制最后一个
    if len(data)%2 != 0 {
        data = append(data, data[len(data)-1])
    }

    // 创建叶子节点
    for _, datum := range data {
        node := NewMerkleNode(nil, nil, datum)
        nodes = append(nodes, *node)
    }

    // 逐层构建树
    for len(nodes) > 1 {
        var newLevel []MerkleNode

        // 如果当前层节点数为奇数，复制最后一个
        if len(nodes)%2 != 0 {
            nodes = append(nodes, nodes[len(nodes)-1])
        }

        for j := 0; j < len(nodes); j += 2 {
            node := NewMerkleNode(&nodes[j], &nodes[j+1], nil)
            newLevel = append(newLevel, *node)
        }

        nodes = newLevel
    }

    mTree := MerkleTree{&nodes[0]}

    return &mTree
}

// 设置交易ID
func (tx *Transaction) Hash() []byte {
    var hash [32]byte

    txCopy := *tx
    txCopy.ID = []byte{}

    hash = sha256.Sum256(txCopy.Serialize())

    return hash[:]
}

// 序列化交易
func (tx Transaction) Serialize() []byte {
    var encoded bytes.Buffer

    enc := gob.NewEncoder(&encoded)
    err := enc.Encode(tx)
    if err != nil {
        log.Panic(err)
    }

    return encoded.Bytes()
}

// 创建Coinbase交易（挖矿奖励）
func NewCoinbaseTX(to, data string) *Transaction {
    if data == "" {
        data = fmt.Sprintf("Reward to '%s'", to)
    }

    txin := TXInput{[]byte{}, -1, nil, []byte(data)}
    txout := NewTXOutput(blockReward*100000000, to) // 转换为聪
    tx := Transaction{nil, []TXInput{txin}, []TXOutput{*txout}}
    tx.ID = tx.Hash()

    return &tx
}

// 创建UTXO交易
func NewUTXOTransaction(wallet *Wallet, to string, amount int, UTXOSet *UTXOSet) *Transaction {
    var inputs []TXInput
    var outputs []TXOutput

    pubKeyHash := HashPubKey(wallet.PublicKey)
    acc, validOutputs := UTXOSet.FindSpendableOutputs(pubKeyHash, amount)

    if acc < amount {
        log.Panic("ERROR: Not enough funds")
    }

    // 构建输入列表
    for txid, outs := range validOutputs {
        txID, err := hex.DecodeString(txid)
        if err != nil {
            log.Panic(err)
        }

        for _, out := range outs {
            input := TXInput{txID, out, nil, wallet.PublicKey}
            inputs = append(inputs, input)
        }
    }

    // 构建输出列表
    from := fmt.Sprintf("%s", wallet.GetAddress())
    outputs = append(outputs, *NewTXOutput(amount, to))
    if acc > amount {
        // 找零
        outputs = append(outputs, *NewTXOutput(acc-amount, from))
    }

    tx := Transaction{nil, inputs, outputs}
    tx.ID = tx.Hash()
    UTXOSet.Blockchain.SignTransaction(&tx, wallet.PrivateKey)

    return &tx
}

// 检查是否为Coinbase交易
func (tx Transaction) IsCoinbase() bool {
    return len(tx.Vin) == 1 && len(tx.Vin[0].Txid) == 0 && tx.Vin[0].Vout == -1
}

// 创建交易输出
func NewTXOutput(value int, address string) *TXOutput {
    txo := &TXOutput{value, nil}
    txo.Lock([]byte(address))

    return txo
}

// 锁定输出到地址
func (out *TXOutput) Lock(address []byte) {
    pubKeyHash := Base58Decode(address)
    pubKeyHash = pubKeyHash[1 : len(pubKeyHash)-addressChecksumLen]
    out.PubKeyHash = pubKeyHash
}

// 检查输出是否被指定公钥哈希锁定
func (out *TXOutput) IsLockedWithKey(pubKeyHash []byte) bool {
    return bytes.Compare(out.PubKeyHash, pubKeyHash) == 0
}

// 检查输入是否使用了指定公钥
func (in *TXInput) UsesKey(pubKeyHash []byte) bool {
    lockingHash := HashPubKey(in.PubKey)
    return bytes.Compare(lockingHash, pubKeyHash) == 0
}

// 创建区块
func NewBlock(transactions []*Transaction, prevBlockHash []byte, height int) *Block {
    block := &Block{
        Timestamp:     time.Now().Unix(),
        Transactions:  transactions,
        PrevBlockHash: prevBlockHash,
        Hash:          []byte{},
        Nonce:         0,
        Height:        height,
    }

    // 执行工作量证明
    pow := NewProofOfWork(block)
    nonce, hash := pow.Run()

    block.Hash = hash[:]
    block.Nonce = nonce

    return block
}

// 创建创世区块
func NewGenesisBlock(coinbase *Transaction) *Block {
    return NewBlock([]*Transaction{coinbase}, []byte{}, 0)
}

// 创建区块链
func CreateBlockchain(address, nodeID string) *Blockchain {
    dbFile := fmt.Sprintf("blockchain_%s.db", nodeID)
    if dbExists(dbFile) {
        fmt.Println("Blockchain already exists.")
        os.Exit(1)
    }

    var tip []byte

    cbtx := NewCoinbaseTX(address, "Genesis Block")
    genesis := NewGenesisBlock(cbtx)

    db := openDB(dbFile)
    err := db.Update(func(txn *Txn) error {
        // 存储区块
        err := txn.Set(genesis.Hash, genesis.Serialize())
        if err != nil {
            return err
        }

        // 存储最新区块哈希
        err = txn.Set([]byte("l"), genesis.Hash)
        if err != nil {
            return err
        }
        tip = genesis.Hash

        return nil
    })

    if err != nil {
        log.Panic(err)
    }

    bc := Blockchain{tip, db}

    return &bc
}

// 添加区块到区块链
func (bc *Blockchain) MineBlock(transactions []*Transaction) *Block {
    var lastHash []byte
    var lastHeight int

    // 验证所有交易
    for _, tx := range transactions {
        if bc.VerifyTransaction(tx) != true {
            log.Panic("ERROR: Invalid transaction")
        }
    }

    // 获取最新区块信息
    err := bc.db.View(func(txn *Txn) error {
        lastHash = txn.Get([]byte("l"))
        blockData := txn.Get(lastHash)
        block := DeserializeBlock(blockData)
        lastHeight = block.Height
        return nil
    })

    if err != nil {
        log.Panic(err)
    }

    // 创建新区块
    newBlock := NewBlock(transactions, lastHash, lastHeight+1)

    // 存储新区块
    err = bc.db.Update(func(txn *Txn) error {
        err := txn.Set(newBlock.Hash, newBlock.Serialize())
        if err != nil {
            return err
        }

        err = txn.Set([]byte("l"), newBlock.Hash)
        if err != nil {
            return err
        }

        bc.tip = newBlock.Hash

        return nil
    })

    if err != nil {
        log.Panic(err)
    }

    return newBlock
}

// 序列化区块
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()
}

// 反序列化区块
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
}

// UTXO集合中的交易输出
type TXOutputs struct {
    Outputs []TXOutput
}

// 查找可花费的输出
func (u UTXOSet) FindSpendableOutputs(pubkeyHash []byte, amount int) (int, map[string][]int) {
    unspentOutputs := make(map[string][]int)
    accumulated := 0
    db := u.Blockchain.db

    err := db.View(func(txn *Txn) error {
        cursor := txn.NewCursor()

        for k, v := cursor.Seek([]byte("utxo-")); bytes.HasPrefix(k, []byte("utxo-")); k, v = cursor.Next() {
            txID := hex.EncodeToString(k[5:])
            outs := DeserializeOutputs(v)

            for outIdx, out := range outs.Outputs {
                if out.IsLockedWithKey(pubkeyHash) && accumulated < amount {
                    accumulated += out.Value
                    unspentOutputs[txID] = append(unspentOutputs[txID], outIdx)
                }
            }
        }

        return nil
    })

    if err != nil {
        log.Panic(err)
    }

    return accumulated, unspentOutputs
}

// 查找指定地址的UTXO
func (u UTXOSet) FindUTXO(pubKeyHash []byte) []TXOutput {
    var UTXOs []TXOutput
    db := u.Blockchain.db

    err := db.View(func(txn *Txn) error {
        cursor := txn.NewCursor()

        for k, v := cursor.Seek([]byte("utxo-")); bytes.HasPrefix(k, []byte("utxo-")); k, v = cursor.Next() {
            outs := DeserializeOutputs(v)

            for _, out := range outs.Outputs {
                if out.IsLockedWithKey(pubKeyHash) {
                    UTXOs = append(UTXOs, out)
                }
            }
        }

        return nil
    })

    if err != nil {
        log.Panic(err)
    }

    return UTXOs
}

// 重建UTXO集合
func (u UTXOSet) Reindex() {
    db := u.Blockchain.db
    bucketName := []byte("utxo-")

    // 删除旧的UTXO集合
    err := db.Update(func(txn *Txn) error {
        cursor := txn.NewCursor()
        for k, _ := cursor.Seek(bucketName); bytes.HasPrefix(k, bucketName); k, _ = cursor.Next() {
            err := txn.Delete(k)
            if err != nil {
                return err
            }
        }
        return nil
    })

    if err != nil {
        log.Panic(err)
    }

    // 查找所有未花费输出
    UTXO := u.Blockchain.FindUTXO()

    // 存储新的UTXO集合
    err = db.Update(func(txn *Txn) error {
        for txID, outs := range UTXO {
            key := append(bucketName, []byte(txID)...)
            err := txn.Set(key, outs.Serialize())
            if err != nil {
                return err
            }
        }

        return nil
    })

    if err != nil {
        log.Panic(err)
    }
}

// 更新UTXO集合
func (u UTXOSet) Update(block *Block) {
    db := u.Blockchain.db

    err := db.Update(func(txn *Txn) error {
        for _, tx := range block.Transactions {
            if tx.IsCoinbase() == false {
                // 删除已花费的输出
                for _, vin := range tx.Vin {
                    updatedOuts := TXOutputs{}
                    key := append([]byte("utxo-"), vin.Txid...)
                    outsBytes := txn.Get(key)
                    outs := DeserializeOutputs(outsBytes)

                    for outIdx, out := range outs.Outputs {
                        if outIdx != vin.Vout {
                            updatedOuts.Outputs = append(updatedOuts.Outputs, out)
                        }
                    }

                    if len(updatedOuts.Outputs) == 0 {
                        err := txn.Delete(key)
                        if err != nil {
                            return err
                        }
                    } else {
                        err := txn.Set(key, updatedOuts.Serialize())
                        if err != nil {
                            return err
                        }
                    }
                }
            }

            // 添加新的输出
            newOutputs := TXOutputs{}
            for _, out := range tx.Vout {
                newOutputs.Outputs = append(newOutputs.Outputs, out)
            }

            key := append([]byte("utxo-"), tx.ID...)
            err := txn.Set(key, newOutputs.Serialize())
            if err != nil {
                return err
            }
        }

        return nil
    })

    if err != nil {
        log.Panic(err)
    }
}

// 序列化输出
func (outs TXOutputs) Serialize() []byte {
    var buff bytes.Buffer

    enc := gob.NewEncoder(&buff)
    err := enc.Encode(outs)
    if err != nil {
        log.Panic(err)
    }

    return buff.Bytes()
}

// 反序列化输出
func DeserializeOutputs(data []byte) TXOutputs {
    var outputs TXOutputs

    dec := gob.NewDecoder(bytes.NewReader(data))
    err := dec.Decode(&outputs)
    if err != nil {
        log.Panic(err)
    }

    return outputs
}

import (
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "encoding/hex"
    "math/big"
)

// 钱包结构
type Wallet struct {
    PrivateKey ecdsa.PrivateKey
    PublicKey  []byte
}

// 创建钱包
func NewWallet() *Wallet {
    private, public := newKeyPair()
    wallet := Wallet{private, public}

    return &wallet
}

// 生成密钥对
func newKeyPair() (ecdsa.PrivateKey, []byte) {
    curve := elliptic.P256()
    private, err := ecdsa.GenerateKey(curve, rand.Reader)
    if err != nil {
        log.Panic(err)
    }
    pubKey := append(private.PublicKey.X.Bytes(), private.PublicKey.Y.Bytes()...)

    return *private, pubKey
}

// 获取地址
func (w Wallet) GetAddress() []byte {
    pubKeyHash := HashPubKey(w.PublicKey)

    versionedPayload := append([]byte{version}, pubKeyHash...)
    checksum := checksum(versionedPayload)

    fullPayload := append(versionedPayload, checksum...)
    address := Base58Encode(fullPayload)

    return address
}

// 公钥哈希
func HashPubKey(pubKey []byte) []byte {
    publicSHA256 := sha256.Sum256(pubKey)

    RIPEMD160Hasher := ripemd160.New()
    _, err := RIPEMD160Hasher.Write(publicSHA256[:])
    if err != nil {
        log.Panic(err)
    }
    publicRIPEMD160 := RIPEMD160Hasher.Sum(nil)

    return publicRIPEMD160
}

// 计算校验和
func checksum(payload []byte) []byte {
    firstSHA := sha256.Sum256(payload)
    secondSHA := sha256.Sum256(firstSHA[:])

    return secondSHA[:addressChecksumLen]
}

// 签名交易
func (bc *Blockchain) SignTransaction(tx *Transaction, privKey ecdsa.PrivateKey) {
    prevTXs := make(map[string]Transaction)

    for _, vin := range tx.Vin {
        prevTX, err := bc.FindTransaction(vin.Txid)
        if err != nil {
            log.Panic(err)
        }
        prevTXs[hex.EncodeToString(prevTX.ID)] = prevTX
    }

    tx.Sign(privKey, prevTXs)
}

// 交易签名
func (tx *Transaction) Sign(privKey ecdsa.PrivateKey, prevTXs map[string]Transaction) {
    if tx.IsCoinbase() {
        return
    }

    for _, vin := range tx.Vin {
        if prevTXs[hex.EncodeToString(vin.Txid)].ID == nil {
            log.Panic("ERROR: Previous transaction is not correct")
        }
    }

    txCopy := tx.TrimmedCopy()

    for inID, vin := range txCopy.Vin {
        prevTx := prevTXs[hex.EncodeToString(vin.Txid)]
        txCopy.Vin[inID].Signature = nil
        txCopy.Vin[inID].PubKey = prevTx.Vout[vin.Vout].PubKeyHash

        dataToSign := fmt.Sprintf("%x\n", txCopy)

        r, s, err := ecdsa.Sign(rand.Reader, &privKey, []byte(dataToSign))
        if err != nil {
            log.Panic(err)
        }
        signature := append(r.Bytes(), s.Bytes()...)

        tx.Vin[inID].Signature = signature
        txCopy.Vin[inID].PubKey = nil
    }
}

// 验证交易
func (bc *Blockchain) VerifyTransaction(tx *Transaction) bool {
    if tx.IsCoinbase() {
        return true
    }

    prevTXs := make(map[string]Transaction)

    for _, vin := range tx.Vin {
        prevTX, err := bc.FindTransaction(vin.Txid)
        if err != nil {
            log.Panic(err)
        }
        prevTXs[hex.EncodeToString(prevTX.ID)] = prevTX
    }

    return tx.Verify(prevTXs)
}

// 交易验证
func (tx *Transaction) Verify(prevTXs map[string]Transaction) bool {
    if tx.IsCoinbase() {
        return true
    }

    for _, vin := range tx.Vin {
        if prevTXs[hex.EncodeToString(vin.Txid)].ID == nil {
            log.Panic("ERROR: Previous transaction is not correct")
        }
    }

    txCopy := tx.TrimmedCopy()
    curve := elliptic.P256()

    for inID, vin := range tx.Vin {
        prevTx := prevTXs[hex.EncodeToString(vin.Txid)]
        txCopy.Vin[inID].Signature = nil
        txCopy.Vin[inID].PubKey = prevTx.Vout[vin.Vout].PubKeyHash

        r := big.Int{}
        s := big.Int{}
        sigLen := len(vin.Signature)
        r.SetBytes(vin.Signature[:(sigLen / 2)])
        s.SetBytes(vin.Signature[(sigLen / 2):])

        x := big.Int{}
        y := big.Int{}
        keyLen := len(vin.PubKey)
        x.SetBytes(vin.PubKey[:(keyLen / 2)])
        y.SetBytes(vin.PubKey[(keyLen / 2):])

        dataToVerify := fmt.Sprintf("%x\n", txCopy)

        rawPubKey := ecdsa.PublicKey{Curve: curve, X: &x, Y: &y}
        if ecdsa.Verify(&rawPubKey, []byte(dataToVerify), &r, &s) == false {
            return false
        }
        txCopy.Vin[inID].PubKey = nil
    }

    return true
}

// 创建交易副本（用于签名）
func (tx *Transaction) TrimmedCopy() Transaction {
    var inputs []TXInput
    var outputs []TXOutput

    for _, vin := range tx.Vin {
        inputs = append(inputs, TXInput{vin.Txid, vin.Vout, nil, nil})
    }

    for _, vout := range tx.Vout {
        outputs = append(outputs, TXOutput{vout.Value, vout.PubKeyHash})
    }

    txCopy := Transaction{tx.ID, inputs, outputs}

    return txCopy
}

import (
    "bytes"
    "encoding/binary"
)

// 整数转字节
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()
}

// Base58编码字符集
var b58Alphabet = []byte("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz")

// Base58编码
func Base58Encode(input []byte) []byte {
    var result []byte

    x := big.NewInt(0).SetBytes(input)

    base := big.NewInt(int64(len(b58Alphabet)))
    zero := big.NewInt(0)
    mod := &big.Int{}

    for x.Cmp(zero) != 0 {
        x.DivMod(x, base, mod)
        result = append(result, b58Alphabet[mod.Int64()])
    }

    // 反转
    ReverseBytes(result)

    // 添加前导零
    for b := range input {
        if b == 0x00 {
            result = append([]byte{b58Alphabet[0]}, result...)
        } else {
            break
        }
    }

    return result
}

// Base58解码
func Base58Decode(input []byte) []byte {
    result := big.NewInt(0)

    for _, b := range input {
        charIndex := bytes.IndexByte(b58Alphabet, b)
        result.Mul(result, big.NewInt(58))
        result.Add(result, big.NewInt(int64(charIndex)))
    }

    decoded := result.Bytes()

    // 添加前导零
    for b := range input {
        if b == b58Alphabet[0] {
            decoded = append([]byte{0x00}, decoded...)
        } else {
            break
        }
    }

    return decoded
}

// 反转字节数组
func ReverseBytes(data []byte) {
    for i, j := 0, len(data)-1; i < j; i, j = i+1, j-1 {
        data[i], data[j] = data[j], data[i]
    }
}

// 验证地址
func ValidateAddress(address string) bool {
    pubKeyHash := Base58Decode([]byte(address))
    actualChecksum := pubKeyHash[len(pubKeyHash)-addressChecksumLen:]
    version := pubKeyHash[0]
    pubKeyHash = pubKeyHash[1 : len(pubKeyHash)-addressChecksumLen]
    targetChecksum := checksum(append([]byte{version}, pubKeyHash...))

    return bytes.Compare(actualChecksum, targetChecksum) == 0
}

import (
    "flag"
    "fmt"
    "os"
)

// CLI结构
type CLI struct{}

// 打印使用说明
func (cli *CLI) printUsage() {
    fmt.Println("Usage:")
    fmt.Println("  createblockchain -address ADDRESS - 创建区块链")
    fmt.Println("  createwallet - 创建新钱包")
    fmt.Println("  getbalance -address ADDRESS - 获取余额")
    fmt.Println("  listaddresses - 列出所有地址")
    fmt.Println("  printchain - 打印区块链")
    fmt.Println("  send -from FROM -to TO -amount AMOUNT - 发送交易")
    fmt.Println("  reindexutxo - 重建UTXO集合")
}

// 验证参数
func (cli *CLI) validateArgs() {
    if len(os.Args) < 2 {
        cli.printUsage()
        os.Exit(1)
    }
}

// 运行CLI
func (cli *CLI) Run() {
    cli.validateArgs()

    nodeID := os.Getenv("NODE_ID")
    if nodeID == "" {
        fmt.Printf("NODE_ID env. var is not set!")
        os.Exit(1)
    }

    getBalanceCmd := flag.NewFlagSet("getbalance", flag.ExitOnError)
    createBlockchainCmd := flag.NewFlagSet("createblockchain", flag.ExitOnError)
    createWalletCmd := flag.NewFlagSet("createwallet", flag.ExitOnError)
    listAddressesCmd := flag.NewFlagSet("listaddresses", flag.ExitOnError)
    printChainCmd := flag.NewFlagSet("printchain", flag.ExitOnError)
    reindexUTXOCmd := flag.NewFlagSet("reindexutxo", flag.ExitOnError)
    sendCmd := flag.NewFlagSet("send", flag.ExitOnError)

    getBalanceAddress := getBalanceCmd.String("address", "", "查询余额的地址")
    createBlockchainAddress := createBlockchainCmd.String("address", "", "接收挖矿奖励的地址")
    sendFrom := sendCmd.String("from", "", "源地址")
    sendTo := sendCmd.String("to", "", "目标地址")
    sendAmount := sendCmd.Int("amount", 0, "发送金额")

    switch os.Args[1] {
    case "getbalance":
        err := getBalanceCmd.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 "createwallet":
        err := createWalletCmd.Parse(os.Args[2:])
        if err != nil {
            log.Panic(err)
        }
    case "listaddresses":
        err := listAddressesCmd.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 "reindexutxo":
        err := reindexUTXOCmd.Parse(os.Args[2:])
        if err != nil {
            log.Panic(err)
        }
    case "send":
        err := sendCmd.Parse(os.Args[2:])
        if err != nil {
            log.Panic(err)
        }
    default:
        cli.printUsage()
        os.Exit(1)
    }

    if getBalanceCmd.Parsed() {
        if *getBalanceAddress == "" {
            getBalanceCmd.Usage()
            os.Exit(1)
        }
        cli.getBalance(*getBalanceAddress, nodeID)
    }

    if createBlockchainCmd.Parsed() {
        if *createBlockchainAddress == "" {
            createBlockchainCmd.Usage()
            os.Exit(1)
        }
        cli.createBlockchain(*createBlockchainAddress, nodeID)
    }

    if createWalletCmd.Parsed() {
        cli.createWallet(nodeID)
    }

    if listAddressesCmd.Parsed() {
        cli.listAddresses(nodeID)
    }

    if printChainCmd.Parsed() {
        cli.printChain(nodeID)
    }

    if reindexUTXOCmd.Parsed() {
        cli.reindexUTXO(nodeID)
    }

    if sendCmd.Parsed() {
        if *sendFrom == "" || *sendTo == "" || *sendAmount <= 0 {
            sendCmd.Usage()
            os.Exit(1)
        }

        cli.send(*sendFrom, *sendTo, *sendAmount, nodeID)
    }
}

// 主函数
func main() {
    defer os.Exit(0)

    cli := CLI{}
    cli.Run()
}