Bitcoin Core 源碼結構解析：從理論到實作

概述

Bitcoin Core 是比特幣網路的參考實現，其源碼是理解比特幣協議的最佳資源。本文深入分析 Bitcoin Core 的源碼結構、主要组件的實作原理，以及開發者如何參與貢獻。

Bitcoin Core 專案概述

專案歷史

技術棧

Bitcoin Core 主要使用 C++ 開發：

• 核心語言：C++ (C++11/14/17 標準)
• 構建系統：Autotools / CMake
• 測試框架：Google Test, unittest
• 依賴庫：LevelDB, Berkeley DB, OpenSSL, secp256k1

源碼目錄結構

頂層目錄

bitcoin/
├── src/              # 主要源代碼
├── test/             # 單元測試與功能測試
├── doc/              # 技術文檔
├── contrib/          # 第三方工具與腳本
└── configure.ac      # 構建配置

src/ 目錄結構

src/
├── bitcoind.cpp      # 主程序入口
├── init.cpp          # 初始化邏輯
├── net.cpp           # P2P 網路通信
├── net_processing.cpp # 網路訊息處理
├── txmempool.cpp     # 記憶池管理
├── validation.cpp    # 區塊驗證邏輯
├── coins.cpp         # UTXO 集合管理
├── script/           # 腳本解釋器
├── primitives/       # 基礎數據類型
├── policy/           # 費用估算與策略
├── rpc/              # RPC 接口
├── wallet/           # 錢包功能
└── consensus/        # 共識規則

核心組件詳解

1. 交易驗證 (validation.cpp)

交易驗證是比特幣網路的心臟，位於 validation.cpp 中：

// 簡化的交易驗證流程
class CChainState {
public:
    // 區塊驗證的主要入口
    bool AcceptToMemoryPool(...);

private:
    // 驗證交易的共識規則
    bool CheckTransaction(...);

    // 驗證腳本
    bool VerifyScript(...);
};

交易驗證的關鍵步驟

1. 基本格式驗證

• 交易大小限制 (MAXSTANDARDTX_WEIGHT)
• 版本號檢查
• 輸入輸出數量限制

1. 輸入引用驗證

• 檢查輸入引用的 UTXO 是否存在
• 驗證輸入金額是否有效

1. 腳本驗證

• P2PKH, P2SH, P2WPKH, P2WSH, P2TR 支持
• 簽名驗證
• 腳本執行環境檢查

1. 費用驗證

• 費用率檢查 (minRelayTxFee)
• 語義腳本驗證

2. 記憶池管理 (txmempool.cpp)

記憶池（Mempool）是未確認交易的臨時儲存區：

class CTxMemPool {
public:
    // 添加交易到記憶池
    bool addUnchecked(...);

    // 獲取費用估算
    estimateFee(...);

private:
    std::map<uint256, CTxMemPoolEntry> mapTx;
    indexed_transaction_map mapTxIdx;
};

記憶池關鍵特性

• 收費率排序：交易按 feerate (sat/vB) 降序排列
• 內存管理：限制總記憶池大小 (預設 300MB)
• 繼承費用：子交易可使用父交易的費用
• 隔離見證：支持 SegWit 交易的費用計算

3. 區塊共識規則 (consensus/)

共識規則決定了什麼是「有效的比特幣區塊」：

// consensus/validation.h
enum {
    // 區塊大小限制
    MAX_BLOCK_SERIALIZED_SIZE = 4'000'000,
    MAX_BLOCK_WEIGHT = 4'000'000,

    // 最大 sigops
    MAX_BLOCK_SIGOPS_COST = 80'000,

    // Coinbase 獎勵
    COINBASE_PAYMENT = 50 * COIN,
};

共識升級機制

比特幣通過 BIP 實現共識升級：

共識層深度分析

比特幣共識層是整個系統的核心，決定了區塊的有效性和網路的的安全性。以下是共識層的深度技術分析：

區塊驗證流程 (Consensus::CheckBlock)

當節點接收到新區塊時，會執行完整的共識驗證。核心函數位於 validation.cpp 的 CheckBlock()：

第一階段：結構驗證

// 區塊基本結構驗證
bool CheckBlock(const CBlock& block, CValidationState& state,
                 const CChainParams& params) {
    // 1. 檢查區塊頭不為空
    if (block.header.IsNull() && !block.vtx.empty())
        return state.DoS(100, false, REJECT_INVALID, "bad-blk-length");

    // 2. 檢查區塊大小
    auto blockSize = ::GetSerializeSize(block, SER_NETWORK, PROTOCOL_VERSION);
    if (blockSize > MAX_BLOCK_SERIALIZED_SIZE)
        return state.DoS(100, false, REJECT_INVALID, "bad-blk-length");

    // 3. 檢查交易列表不為空（創世區塊除外）
    if (block.vtx.empty())
        return state.DoS(100, false, REJECT_INVALID, "bad-blk-length");

    // 4. 檢查 coinbase 交易存在
    if (!block.vtx[0]->IsCoinBase())
        return state.DoS(100, false, REJECT_INVALID, "bad-cb-missing");

    // 5. 檢查其他交易不是 coinbase
    for (size_t i = 1; i < block.vtx.size(); i++) {
        if (block.vtx[i]->IsCoinBase())
            return state.DoS(100, false, REJECT_INVALID, "bad-cb-multiple");
    }
}

第二階段：交易驗證

每筆交易都會經過 CheckTransaction() 驗證：

bool CheckTransaction(const CTransaction& tx, CValidationState& state) {
    // 基本檢查
    if (tx.vin.empty() || tx.vout.empty())
        return state.DoS(10, false, REJECT_INVALID, "bad-txns-vin-vout-empty");

    // 金額範圍檢查（避免整數溢出）
    for (const auto& out : tx.vout) {
        if (out.nValue < 0)
            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-negative");
        if (out.nValue > MAX_MONEY)
            return state.DoS(100, false, REJECT_INVALID, "bad-txns-vout-toolarge");
    }

    // 簽名操作數上限
    if (GetSigOpCount(tx) > MAX_BLOCK_SIGOPS_COST)
        return state.DoS(100, false, REJECT_INVALID, "bad-txns-sigops");

    return true;
}

第三階段：腳本驗證

腳本驗證是共識的核心，決定了誰可以花費輸出。Bitcoin Core 使用基於堆疊的腳本解釋器：

// script/interpreter.cpp
bool EvalScript(std::vector<std::vector<unsigned char>>& stack,
                 const CScript& script, unsigned int flags,
                 const BaseSignatureChecker& checker) {
    for (CScript::const_iterator pc = script.begin(); pc != script.end();) {
        // 獲取操作碼
        opcodetype opcode;
        if (!script.GetOp(pc, opcode))
            return false;

        // 處理常量和操作碼
        if (opcode >= OP_1 && opcode <= OP_16) {
            // 推送數字到堆疊
            stack.push_back(ValN(opcode - OP_1 + 1));
        } else if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY) {
            // 橢圓曲線簽名驗證
            if (!CheckSignatureEncoding(vchSig, flags) ||
                !CheckPubKeyEncoding(vchPubKey, flags))
                return false;
            // 實際的 ECDSA 驗證邏輯...
        }
        // ... 其他操作碼處理
    }
    return true;
}

共識關鍵參數

比特幣共識參數經過精心設計，平衡了安全性、去中心化和性能：

共識分支檢測

當出現分叉時，節點需要判斷哪條是「正確」的鏈。中本聰共識使用「最長鏈原則」：

// validation.cpp
bool CChainState::AcceptBlock(...) {
    // 檢查是否比現有最佳鏈更好
    if (pindex->nChainWork > chainActive.Tip()->nChainWork) {
        // 這個區塊擴展了最佳鏈
        chainActive.SetTip(pindex);
        return true;
    }
    return false;
}

// 難度檢查
bool ContextualCheckBlock(const CBlock& block, CValidationState& state,
                          const CBlockIndex* pindexPrev) {
    int64_t nExpectedTime = pindexPrev->GetMedianTimePast() + Params().GetConsensus().nPowTargetSpacing;
    int64_t nActualTime = block.GetBlockTime();

    // 難度調整驗證（每 2016 區塊）
    if (IsDifficultyTransitionPoint(pindexPrev)) {
        uint256 newTarget = CalculateNextWorkRequired(pindexPrev, ...);
        if (block.nBits != GetCompact(newTarget))
            return state.DoS(100, false, REJECT_INVALID, "bad-diff");
    }
    return true;
}

激勵機制與費用市場

共識層還包括經濟激勵的實現：

// validation.cpp - Coinbase 獎勵計算
CAmount GetBlockSubsidy(int nHeight, const Consensus::Params& params) {
    int halvings = nHeight / params.nSubsidyHalvingInterval;

    // 區塊獎勵每 210,000 區塊減半
    if (halvings >= 64)
        return 0;

    CAmount nSubsidy = params.initialSubsidy >> halvings;
    return nSubsidy;
}

// 費用計算
CAmount GetTransactionFee(const CTransaction& tx, size_t txSize) {
    // 基於交易的 weight 計算費用
    return tx.GetFeePerK();
}

4. P2P 網路 (net.cpp, net_processing.cpp)

網路層負責節點之間的通信：

// 網路消息類型
enum NetMsgType {
    MSG_TX,
    MSG_BLOCK,
    MSG_GETBLOCKS,
    MSG_GETHEADERS,
    // ...
};

消息傳播機制

1. 交易傳播

• 節點接收新交易
• 驗證後廣播給其他節點
• 使用 INV 消息預告

1. 區塊傳播

• 區塊頭優先傳播
• 區塊體按需請求
• Compact Block 優化帶寬

5. 錢包模組 (wallet/)

錢包模組處理密鑰管理與交易構建：

// wallet/wallet.h
class CWallet : public CCryptoKeyStore {
private:
    CCriticalSection cs_wallet;
    std::map<CKeyID, CKey> mapKeys;
    std::map<uint160, Script> mapScripts;

public:
    // 創建交易
    CTransactionRef CreateTransaction(...);

    // 簽名交易
    bool SignTransaction(...);

    // 廣播交易
    BroadcastTransaction(...);
};

錢包類型

腳本引擎 (script/)

比特幣腳本是基於堆棧的執行環境：

操作碼分類

腳本類型演進

// P2PKH: Pay to Public Key Hash
// 鎖定腳本: OP_DUP OP_HASH160 <pubKeyHash> OP_EQUALVERIFY OP_CHECKSIG

// P2SH: Pay to Script Hash
// 鎖定腳本: OP_HASH160 <scriptHash> OP_EQUAL

// P2WPKH: Pay to Witness Public Key Hash
// 鎖定腳本: 0 <pubKeyHash>

// P2TR: Pay to Taproot
// 鎖定腳本: 0 <32-byte-output-key>

RPC 接口

Bitcoin Core 提供 JSON-RPC 接口與外部交互：

常用 RPC 命令

RPC 實現示例

// rpc/blockchain.cpp
UniValue getblockchaininfo(const JSONRPCRequest& request) {
    UniValue result(UniValue::VOBJ);
    result.push_back(Pair("chain", params::NetworkIDString()));
    result.push_back(Pair("blocks", (int)chainActive.Height()));
    result.push_back(Pair("difficulty", (double)GetDifficulty()));
    result.push_back(Pair("mediantime", (int64_t)chainActive.Tip()->GetMedianTimePast()));
    return result;
}

測試框架

單元測試

// test/util/setup_common.cpp
BOOST_FIXTURE_TEST_SUITE(validation_tests, TestingSetup)

BOOST_AUTO_TEST_CASE(tx_mempool_limit)
{
    // 測試記憶池大小限制
}

BOOST_AUTO_TEST_SUITE_END()

功能測試 (Python)

# test/functional/mempool_packages.py
def test_mempool_package(self):
    # 測試 CPFP (Child Pays for Parent)
    # 測試 RBF (Replace-By-Fee)
    pass

模糊測試

// src/test/fuzz/
FUZZ_TARGET(tx_in) {
    // 使用 libFuzzer 進行模糊測試
}

開發者貢獻指南

代碼風格

Bitcoin Core 使用特定的代碼風格：

• 2 空格縮進
• 命名駝峰式
• 必需使用 BDB 風格的條件表達式

提交過程

1. Fork 倉庫
2. 創建分支：基於 v0.XX 或 master
3. 開發與測試
4. 提交 Pull Request
5. 代碼審查
6. 合併

熱門貢獻領域

結論

Bitcoin Core 源碼是理解比特幣協議最權威的資源：

1. 驗證邏輯：validation.cpp 包含完整的交易與區塊驗證
2. 共識規則：consensus/ 目錄定義了比特幣的核心規則
3. 網路通信：net.cpp 實現了節點之間的 P2P 通信
4. 錢包實現：wallet/ 提供了密鑰管理與交易構建

對於比特幣開發者而言，深入研究 Bitcoin Core 源碼是理解比特幣最有效的途徑。

Bitcoin Core RPC 實作教學

RPC 環境設置

Bitcoin Core 提供 JSON-RPC 接口，可透過以下方式連接：

# 啟動 Bitcoin Core 節點
bitcoind -daemon -server -rpcuser=user -rpcpassword=password

# 測試連接
curl --user user:password --data-binary '{"jsonrpc": "1.0", "id": "1", "method": "getblockchaininfo", "params": []}' http://127.0.0.1:8332

使用 Python 與 Bitcoin Core 互動

import requests
import json

class BitcoinRPC:
    def __init__(self, user, password, host='127.0.0.1', port=8332):
        self.url = f"http://{host}:{port}"
        self.auth = (user, password)

    def call(self, method, *params):
        payload = {
            "jsonrpc": "1.0",
            "id": "1",
            "method": method,
            "params": params
        }
        response = requests.post(
            self.url,
            json=payload,
            auth=self.auth
        )
        return response.json()['result']

# 使用範例
btc = BitcoinRPC("user", "password")
info = btc.call("getblockchaininfo")
print(f"Current block height: {info['blocks']}")

建立比特幣交易

步驟 1：獲取 UTXO

# 列出錢包中的未花費交易輸出
unspent = btc.call("listunspent", 6, 9999999)

# 範例輸出：
# [
#     {
#         "txid": "abc123...",
#         "vout": 0,
#         "address": "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa",
#         "amount": 0.5,
#         "confirmations": 10,
#         "scriptPubKey": "76a914..."
#     }
# ]

步驟 2：創建交易

# 創建交易原始數據
txid = "abc123..."
vout = 0
amount_to_send = 0.1  # 發送金額
fee = 0.001  # 手續費

# 計算找零
change_address = btc.call("getnewaddress")
inputs = [{"txid": txid, "vout": vout}]
outputs = {
    "recipient_address": amount_to_send,
    change_address: amount_to_send - fee
}

# 建立交易
raw_tx = btc.call("createrawtransaction", inputs, outputs)
print(f"Raw transaction: {raw_tx}")

步驟 3：簽名交易

# 使用錢包密鑰簽名
signed_tx = btc.call("signrawtransactionwithwallet", raw_tx)
print(f"Signed: {signed_tx['hex']}")
print(f"Complete: {signed_tx['complete']}")

步驟 4：廣播交易

# 廣播到網路
tx_hash = btc.call("sendrawtransaction", signed_tx['hex'])
print(f"Transaction broadcast: {tx_hash}")

使用 libsecp256k1 開發比特幣應用

libsecp256k1 是比特幣使用的橢圓曲線庫，可用於高效的金鑰生成與簽名：

安裝 libsecp256k1

# 從源碼編譯
git clone https://github.com/bitcoin-core/secp256k1.git
cd secp256k1
./autogen.sh
./configure --enable-module-recovery
make
make install

生成金鑰對

#include <secp256k1.h>
#include <stdio.h>
#include <stdlib.h>

int main() {
    // 初始化 context
    secp256k1_context *ctx = secp256k1_context_create(
        SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY
    );

    // 生成隨機種子
    unsigned char seed[32];
    FILE *fp = fopen("/dev/urandom", "r");
    fread(seed, 32, 1, fp);
    fclose(fp);

    // 隨機化 context（防止側信道攻擊）
    secp256k1_context_randomize(ctx, seed);

    // 生成私鑰
    secp256k1_ecdsa_private_key privkey;
    do {
        secp256k1_ecdsa_private_key_gen(&privkey, seed);
    } while (!secp256k1_ecdsa_private_key_is_valid(ctx, &privkey));

    // 推導公鑰
    secp256k1_ecdsa_public_key pubkey;
    secp256k1_ecdsa_public_key_create(ctx, &pubkey, &privkey);

    printf("Key pair generated successfully\n");

    // 清理
    secp256k1_context_destroy(ctx);
    return 0;
}

簽名訊息

// 簽名訊息
secp256k1_ecdsa_signature sig;
unsigned char message[32] = "Hello, Bitcoin!";
unsigned char signature[72];
size_t siglen = 72;

secp256k1_ecdsa_sign(ctx, &sig, message, &privkey, NULL, NULL);
secp256k1_ecdsa_signature_serialize_compact(ctx, signature, &sig);

// 驗證簽名
secp256k1_ecdsa_signature sig_parsed;
secp256k1_ecdsa_signature_parse_compact(ctx, &sig_parsed, signature);

if (secp256k1_ecdsa_verify(ctx, &sig_parsed, message, &pubkey)) {
    printf("Signature verified!\n");
}

Bitcoin Core 開發環境搭建

編譯 Bitcoin Core

# 安裝依賴（Ubuntu/Debian）
sudo apt-get install build-essential libtool autotools-dev automake pkg-config libssl-dev libevent-dev bsdmainutils python3 libboost-system-dev libboost-filesystem-dev libboost-chrono-dev libboost-test-dev libboost-thread-dev libminiupnpc-dev libzmq3-dev

# 克隆源碼
git clone https://github.com/bitcoin/bitcoin.git
cd bitcoin

# 編譯
./autogen.sh
./configure --disable-tests --disable-bench
make -j$(nproc)
sudo make install

# 啟動測試網節點
./src/bitcoind -testnet -daemon

調試 Bitcoin Core

# 啟用調試日誌
./src/bitcoind -debug=1 -debug=mempool

# 使用 gdb 調試
gdb ./src/bitcoind
(gdb) run -testnet

# 查看 RPC 調用追蹤
./src/bitcoind -tracerpc

共識升級開發實務

實現新的共識規則

// 新增共識參數（consensus/params.h）
struct Consensus {
    // ... 現有參數
    bool my_new_feature_enabled;  // 新功能開關
};

// 激活邏輯（chainparams.cpp）
Consensus::Consensus() {
    // 基於 BIP 9 的軟分叉激活
    // 或者基於時間/區塊高度
}

// 驗證新規則（validation.cpp）
bool CheckMyNewRule(const CTransaction& tx, const CBlock& block) {
    if (!DeploymentActiveAt(chainActive.Tip(), consensus_params.my_feature))
        return true;  // 未激活時跳過

    // 實現新規則驗證邏輯
    return true;
}

本文分析 Bitcoin Core 源碼結構與核心組件實作。