比特幣錢包開發完整指南：從基礎到進階

概述

比特幣錢包是管理用戶私鑰並與比特幣網路交互的應用程式。本文涵蓋錢包開發的各個層面，包括錢包類型、密鑰管理、交易構建、安全最佳實踐，以及實際的開發範例。

錢包基礎概念

錢包的核心功能

比特幣錢包的核心職責：

1. 密鑰生成：創建比特幣地址
2. 簽名管理：授權比特幣交易
3. 餘額查詢：查詢區塊鏈餘額
4. 交易構建：創建並廣播比特幣交易
5. 交易歷史：記錄用戶的交易歷史

比特幣地址類型

密鑰管理架構

層級確定性錢包 (HD Wallet)

HD 錢包允許從單一種子生成無限地址：

Seed (256 bits)
    │
    ├── m/44'/0'/0'/0/0  (第一個 Legacy 地址)
    ├── m/44'/0'/0'/0/1  (第二個 Legacy 地址)
    ├── m/84'/0'/0'/0/0  (第一個 Native SegWit)
    └── m/86'/0'/0'/0/0  (第一個 Taproot)

BIP-39 助記詞

// 助記詞到種子的轉換
// 助記詞 (12-24 words) -> PBKDF2 -> 512-bit 種子
std::vector<std::string> mnemonic = {
    "abandon", "abandon", "abandon", "abandon",
    "abandon", "abandon", "abandon", "abandon",
    "abandon", "abandon", "abandon", "about"
};

uint512_t seed = PBKDF2(mnemonic, "mnemonic", 2048);

BIP-32 密鑰派生

// BIP-32 私鑰派生
struct HDKey {
    uint256_t chain_code;
    uint256_t key;

    HDKey derive(uint32_t path) {
        // CKDpriv (Child Key Derivation, private)
        HMAC-SHA512(key = chain_code, data = 0x00 || parent_key || index)
        return {
            .key = left_256(hmac_output) + parent_key mod n,
            .chain_code = right_256(hmac_output)
        };
    }
};

密鑰儲存策略

交易開發實務

比特幣交易結構

struct Transaction {
    uint32_t version;      // 版本號 (4 bytes)
    std::vector<TxIn> vin; // 輸入列表
    std::vector<TxOut> vout; // 輸出列表
    uint32_t lock_time;    // 鎖定時間 (4 bytes)
};

struct TxIn {
    COutPoint prevout;     // 引用上一筆輸出
    CScript script_sig;    // 解鎖腳本
    uint32_t sequence;      // 序列號
};

struct TxOut {
    int64_t value;         // 金額 (satoshis)
    CScript script_pubkey; // 鎖定腳本
};

UTXO 模型

比特幣採用未花費交易輸出 (UTXO) 模型：

// 查詢錢包 UTXO
std::vector<UTXO> getWalletUTXOs(const CKey& privateKey) {
    // 1. 從 RPC 獲取錢包地址
    std::vector<std::string> addresses = listReceivedByAddress(privateKey);

    // 2. 查詢每個地址的 UTXO
    std::vector<UTXO> utxos;
    for (const auto& addr : addresses) {
        auto unspent = RPC::listunspent(addr);
        utxos.insert(utxos.end(), unspent.begin(), unspent.end());
    }

    return utxos;
}

交易構建流程

步驟 1：選擇 UTXO

std::vector<UTXO> selectUTXOs(uint64_t targetAmount, std::vector<UTXO> available) {
    // 使用貪心算法選擇 UTXO
    sort(available.begin(), available.end(), descendingByValue);

    std::vector<UTXO> selected;
    uint64_t total = 0;

    for (const auto& utxo : available) {
        selected.push_back(utxo);
        total += utxo.value;
        if (total >= targetAmount) break;
    }

    return selected;
}

步驟 2：創建交易輸入

Transaction createTransactionInput(UTXO& utxo) {
    return TxIn{
        .prevout = COutPoint(utxo.txid, utxo.vout),
        .script_sig = CScript(),  // 稍後填充
        .sequence = 0xffffffff     // 默認序列號
    };
}

步驟 3：創建交易輸出

TransactionOutput createPaymentOutput(
    const std::string& toAddress,
    uint64_t amount
) {
    CScript scriptPubKey = GetScriptForAddress(toAddress);
    return TxOut{
        .value = amount,
        .script_pubkey = scriptPubKey
    };
}

// 創建找零輸出
TransactionOutput createChangeOutput(
    const CKey& walletKey,
    uint64_t changeAmount
) {
    CScript scriptPubKey = GetScriptForAddress(walletKey.GetPubKey().GetID());
    return TxOut{
        .value = changeAmount,
        .script_pubkey = scriptPubKey
    };
}

步驟 4：計算費用

uint64_t calculateFee(const Transaction& tx, uint64_t feeRate) {
    // 計算交易大小 (vbytes)
    size_t txSize = GetVirtualTransactionSize(tx);

    // 費用 = 大小 × 費率
    return txSize * feeRate;
}

步驟 5：簽名交易

bool signTransaction(
    Transaction& tx,
    const CKey& privateKey,
    const std::vector<UTXO>& utxos
) {
    for (size_t i = 0; i < tx.vin.size(); i++) {
        const auto& utxo = utxos[i];

        // 獲取簽名數據
        SignatureData sigdata;
        sigdata.signature = CreateEcdsaSignature(
            privateKey,
            GetSighash(tx, i, utxo.script_pubkey)
        );

        // 構建 scriptSig
        tx.vin[i].script_sig = Producer(
            sigdata.signature,
            privateKey.GetPubKey()
        );
    }

    return true;
}

錢包類型實現

完整節點錢包

class FullNodeWallet {
private:
    CCriticalSection cs_wallet;
    std::map<CKeyID, CKey> privateKeys;
    CChain& chain;

public:
    // 初始化錢包
    void LoadWallet();

    // 同步區塊鏈
    void SyncWithChain();

    // 掃描交易
    void RescanBlockchain();
};

優點

• 完全驗證交易有效性
• 最佳隱私（不依賴第三方）
• 可運行自己的 RPC 服務

缺點

• 需要大量磁盤空間 (> 500GB)
• 同步時間長

簡化支付驗證 (SPV) 錢包

SPV 錢包只下載區塊頭，不保存完整區塊：

class SPVWallet {
private:
    std::vector<CBlockHeader> headers;
    std::map<uint256, MerkleBlock> filter;

    // 向多個節點請求交易證明
    std::vector<TransactionProof> getTxProof(const uint256& txid);
};

Bloom 過濾器

SPV 錢包使用 Bloom 過濾器保護隱私：

class BloomFilter {
private:
    std::vector<bool> data;
    double fpRate;  // 誤判率

public:
    // 創建過濾器
    BloomFilter(size_t elements, double fpRate);

    // 添加地址到過濾器
    void insert(const std::vector<uint8_t>& elem);

    // 測試元素
    bool contains(const std::vector<uint8_t>& elem) const;
};

硬體錢包

硬體錢包將私鑰存儲在安全晶片中：

常見硬體錢包標準

硬體錢包通信

// 通過 HID 與硬體錢包通信
class HardwareWallet {
public:
    // 獲取公鑰
    virtual PubKey getPublicKey(uint32_t path) = 0;

    // 簽名交易
    virtual std::vector<uint8_t> signTransaction(
        const Transaction& tx,
        uint32_t path
    ) = 0;

    // 確認地址
    virtual std::string getAddress(uint32_t path) = 0;
};

費用估算

費用市場機制

比特幣費用由市場決定，取決於區塊空間需求：

// 費用估算策略
class FeeEstimator {
private:
    // 歷史交易費用數據
    std::map<uint32_t, std::vector<uint64_t>> feeHistory;

public:
    // 估算費用 (sat/vB)
    uint64_t estimateFee(uint32_t targetBlocks);

    // 保守估計
    uint64_t estimateSmartFee(uint32_t targetBlocks);

    // 費用模式分析
    FeeMode analyzeFeeMarket();
};

費用策略

安全性最佳實踐

私鑰安全

1. 從不使用網路傳輸私鑰
2. 離線簽名交易（冷簽名）
3. 使用硬體錢包
4. 多重簽名

// 多重簽名腳本
CScript createMultisigScript(
    uint8_t threshold,
    std::vector<CPubKey> keys
) {
    CScript script;
    script << OP_0;  // 初始スタック

    for (const auto& key : keys) {
        script << ToByteVector(key);
    }

    script << keys.size() << threshold << OP_CHECKMULTISIG;
    return script;
}

交易安全

1. 驗證目標地址
2. 使用 RBF (Replace-By-Fee) 應對費用不足
3. 小額測試交易
4. 備份錢包

節點安全

1. 使用 Tor 隱藏節點 IP
2. 啟用 SSL/TLS 加密 RPC
3. 限制 RPC 訪問

# 安全的 bitcoind 啟動命令
bitcoind \
    -daemon \
    -prune=10000 \
    -maxconnections=15 \
    -bind=127.0.0.1:8333 \
    -rpcbind=127.0.0.1:8332 \
    -rpcuser=username \
    -rpcpassword=password \
    -torcontrol=127.0.0.1:9051 \
    -onion=127.0.0.1:9050

錢包互操作性

錢包導入格式

PSBT 實現

// PSBT (BIP 174)
struct PartiallySignedTransaction {
    uint32_t version;
    std::vector<TxInput> inputs;
    std::vector<TxOutput> outputs;
    std::vector<PSBTGlobal> globals;
    std::vector<PSBTInput> unknown;
};

開發工具與庫

C++ 庫

其他語言庫

結論

比特幣錢包開發涉及多個專業領域：

1. 密鑰管理：HD 錢包、BIP-39/32/44 標準
2. 交易構建：UTXO 選擇、費用計算、簽名
3. 網路通信：SPV 節點、交易廣播
4. 安全實踐：冷儲存、多重簽名、硬體錢包

選擇適合的錢包類型取決於具體使用場景與安全需求。開發者應深入理解比特幣協議底層，以構建安全可靠的錢包應用。

本文提供比特幣錢包開發的完整技術指南。