比特币bitcoin源码解析之整体架构和流程
1. 比特币简介
比特币（BitCoin）的概念最初由中本聪在2009年提出，根据中本聪的思路设计发布的开源软件以及建构其上的P2P网络。比特币是一种P2P形式的数字货币。点对点的传输意味着一个去中心化的支付系统。
与大多数货币不同，比特币不依靠特定货币机构发行，它依据特定算法，通过大量的计算产生，比特币经济使用整个P2P网络中众多节点构成的分布式数据库来确认并记录所有的交易行为，并使用密码学的设计来确保货币流通各个环节安全性。P2P的去中心化特性与算法本身可以确保无法通过大量制造比特币来人为操控币值。基于密码学的设计可以使比特币只能被真实的拥有者转移或支付。这同样确保了货币所有权与流通交易的匿名性。比特币与其他虚拟货币最大的不同，是其总数量非常有限，具有极强的稀缺性。该货币系统曾在4年内只有不超过1050万个，之后的总数量将被永久限制在2100万个。
2. 比特币整体架构
点对点网络，每一个网络中的节点即是Client又是Server，如下图所示：
* 节点和节点之间通过发送消息命令来相互通信的，下图是对应的消息命令格式：
CMessageHeader对应的类图如下所示：
* 节点通信过程中使用的对应的消息命令如下表所示：
| 命令 | 消息内容 | 说明 |
|---|---|---|
| version | nVersion,nService,nTime,address | 版本，服务标识，时间；地址 |
| addr | vector< CAddress> | 地址列表 |
| inv | vector< CInv> | 库存信息列表：将对应的库存发送消息增加到库存发送已知中 |
| getdata | vector< CInv> | 根据inv对应的type执行不同的处理，就是将对应的请求消息转化为待请求的命令放入到节点对应的发送消息缓存中 |
| getblocks | CBlockLocator locator;uint256 hashStop; | 根据locator定位区块在链上位置，从这个位置开始往后找（找对应的next），一直到对应块的block的hash等于hashStop为止，并将所有找到的区块发送库存setInventoryKnown2中等待被发送 |
| Tx | CTransaction | 将交易消息放入到对应的已知库存中，如果此交易能够被接受，则对此消息进行转播，并递归处理所有依赖这个交易对应的孤儿交易；如果交易不被接受，则将次交易放入到孤儿交易列表中mapOrphanTransactions和mapOrphanTransactionsByPrev中 |
| block | CBlock | 块消息：将接收的block放入对应的已知库存中，并对应这个块进行处理，并将此块从mapAlreadyAskedFor咨询中移除 |
3. 比特币整体处理流程
对应的整体流程如下图所示：
3.1 LoadAdreess方法
LoadAdreess方法从地址文件addr.dat中读取对应的地址信息，放入对应的全局内存对象mapAddresses中，其中addr.dat对应的结构如下：
| Key | Value | 说明 | 内存中存放对象 |
|---|---|---|---|
| addr | CAddress | 数据库中保存对应的地址新 | map< vector,CAddress>mapAddresses节点地址映射：key对应的是ip地址+端口，value是CAddress对象 |
3.2 LoadBlockIndex方法
LoadBlockIndex方法从块索引文件blkindex.dat中读取对应的块索引信息，放入对应的全局内存对象mapBlockIndex中，其中blkindex.dat对应的结构如下：
| Key | Value | 说明 | 内存中存放对象 |
|---|---|---|---|
| blockindex | CDiskBlockIndex | 块索引数据库 | map< uint256, CBlockIndex*> mapBlockIndex块索引信息：其中key对应的block的hash值 |
对应的源码如下：
bool LoadBlockIndex(bool fAllowNew)
{
//
// Load block index
//
CTxDB txdb("cr");
if (!txdb.LoadBlockIndex())
return false;
txdb.Close();
//
// Init with genesis block
//
if (mapBlockIndex.empty())
{
if (!fAllowNew)
return false;
// Genesis Block:
// GetHash() = 0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f
// hashMerkleRoot = 0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b
// txNew.vin[0].scriptSig = 486604799 4 0x736B6E616220726F662074756F6C69616220646E6F63657320666F206B6E697262206E6F20726F6C6C65636E61684320393030322F6E614A2F33302073656D695420656854
// txNew.vout[0].nValue = 5000000000
// txNew.vout[0].scriptPubKey = 0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704 OP_CHECKSIG
// block.nVersion = 1
// block.nTime = 1231006505
// block.nBits = 0x1d00ffff
// block.nNonce = 2083236893
// CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
// CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
// CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
// CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
// vMerkleTree: 4a5e1e
// Genesis block
char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
CTransaction txNew;
txNew.vin.resize(1);
txNew.vout.resize(1);
txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((unsigned char*)pszTimestamp, (unsigned char*)pszTimestamp + strlen(pszTimestamp));
txNew.vout[0].nValue = 50 * COIN;
txNew.vout[0].scriptPubKey = CScript() << CBigNum("0x5F1DF16B2B704C8A578D0BBAF74D385CDE12C11EE50455F3C438EF4C3FBCF649B6DE611FEAE06279A60939E028A8D65C10B73071A6F16719274855FEB0FD8A6704") << OP_CHECKSIG;
CBlock block;
block.vtx.push_back(txNew);
block.hashPrevBlock = 0;
block.hashMerkleRoot = block.BuildMerkleTree();
block.nVersion = 1;
block.nTime = 1231006505;
block.nBits = 0x1d00ffff;
block.nNonce = 2083236893;
//// debug print, delete this later
printf("%s\n", block.GetHash().ToString().c_str());
printf("%s\n", block.hashMerkleRoot.ToString().c_str());
printf("%s\n", hashGenesisBlock.ToString().c_str());
txNew.vout[0].scriptPubKey.print();
block.print();
assert(block.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
assert(block.GetHash() == hashGenesisBlock);
// Start new block file
unsigned int nFile;
unsigned int nBlockPos;
if (!block.WriteToDisk(!fClient, nFile, nBlockPos))
return error("LoadBlockIndex() : writing genesis block to disk failed");
if (!block.AddToBlockIndex(nFile, nBlockPos))
return error("LoadBlockIndex() : genesis block not accepted");
}
return true;
}3.3 LoadWallet方法
LoadWallet方法从文件wallet.dat中读取对应的钱包交易信息和其他的配置信息，放入到不同的全局内存对象中，其中wallet.dat对应的格式（key-value结构）如下所示：
| Key | Value | 说明 | 内存中存放对象 | |
|---|---|---|---|---|
| Type | Key1 | Key分为类型类型和key | ||
| name | 比特币地址 | 比特币地址对应名称 | 地址和名称之间映射 | map< string,string> mapAddressBook地址和名称的映射，其中key为地址，value为名称 |
| Tx | 交易hash值 | 钱包交易对象CWalletTx | 交易hash与交易之间映射 | map< uint256, CWalletTx>mapWalle钱包交易对应的map，其中key对应的钱包交易的hash值 |
| Key | 公钥 | 私钥 | 公钥和私钥对应关系 | map< vector< unsigned char>, CPrivKey> mapKeys公钥和私钥对应的映射关系，其中key为公钥，value为私钥；map< uint160, vector > mapPubKeys公钥的hash值和公钥的关系，其中key为公钥的hash值，value为公钥 |
| defaultkey | vector< unsigned char> vchDefaultKeyRet | 默认key对应对应的值 | ||
| setting | fGenerateBitcoins | 是否产生比特币标记 | 是否挖矿标记 | int fGenerateBitcoins |
| setting | nTransactionFee | 交易手续费的值 | 交易手续费 | int64 nTransactionFee |
| setting | addrIncoming | CAddress对象 | 获得当前对应的外部地址，用于接收外部的连接 | CAddress addrIncoming |
源码内容如下：
//
// CWalletDB
//
bool CWalletDB::LoadWallet(vector<unsigned char>& vchDefaultKeyRet)
{
vchDefaultKeyRet.clear();
//// todo: shouldn't we catch exceptions and try to recover and continue?
CRITICAL_BLOCK(cs_mapKeys)
CRITICAL_BLOCK(cs_mapWallet)
{
// Get cursor
Dbc* pcursor = GetCursor();
if (!pcursor)
return false;
loop
{
// Read next record
CDataStream ssKey;
CDataStream ssValue;
int ret = ReadAtCursor(pcursor, ssKey, ssValue);
if (ret == DB_NOTFOUND)
break;
else if (ret != 0)
return false;
// Unserialize
// Taking advantage of the fact that pair serialization
// is just the two items serialized one after the other
string strType;
ssKey >> strType;
if (strType == "name")
{
string strAddress;
ssKey >> strAddress;
ssValue >> mapAddressBook[strAddress];
}
else if (strType == "tx")
{
uint256 hash;
ssKey >> hash;
CWalletTx& wtx = mapWallet[hash];
ssValue >> wtx;
if (wtx.GetHash() != hash)
printf("Error in wallet.dat, hash mismatch\n");
//// debug print
//printf("LoadWallet %s\n", wtx.GetHash().ToString().c_str());
//printf(" %12I64d %s %s %s\n",
// wtx.vout[0].nValue,
// DateTimeStr(wtx.nTime).c_str(),
// wtx.hashBlock.ToString().substr(0,14).c_str(),
// wtx.mapValue["message"].c_str());
}
else if (strType == "key")
{
vector<unsigned char> vchPubKey;
ssKey >> vchPubKey;
CPrivKey vchPrivKey;
ssValue >> vchPrivKey;
mapKeys[vchPubKey] = vchPrivKey;
mapPubKeys[Hash160(vchPubKey)] = vchPubKey;
}
else if (strType == "defaultkey")
{
ssValue >> vchDefaultKeyRet;
}
else if (strType == "setting") /// or settings or option or options or config?
{
string strKey;
ssKey >> strKey;
if (strKey == "fGenerateBitcoins") ssValue >> fGenerateBitcoins;
if (strKey == "nTransactionFee") ssValue >> nTransactionFee;
if (strKey == "addrIncoming") ssValue >> addrIncoming;
}
}
}
printf("fGenerateBitcoins = %d\n", fGenerateBitcoins);
printf("nTransactionFee = %I64d\n", nTransactionFee);
printf("addrIncoming = %s\n", addrIncoming.ToString().c_str());
return true;
}3.4节点通信线程
启动了三个主要的线程，ThreadOpenConnections，ThreadSocketHandler和ThreadMessageHandler，这个三个线程对应的主要处理流程分别如下图所示：
3.4.1线程ThreadOpenConnections
线程ThreadOpenConnections对应的处理流程如下图所示：
源码如下：
// 对于每一个打开节点的链接，进行节点之间信息通信，获得节点对应的最新信息，比如节点对应的知道地址进行交换等
void ThreadOpenConnections2(void* parg)
{
printf("ThreadOpenConnections started\n");
// 初始化网络连接
// Initiate network connections
const int nMaxConnections = 15; // 最大连接数
loop
{
// Wait
vfThreadRunning[1] = false;
Sleep(500);
while (vNodes.size() >= nMaxConnections || vNodes.size() >= mapAddresses.size())
{
CheckForShutdown(1);
Sleep(2000);
}
vfThreadRunning[1] = true;
CheckForShutdown(1);
// Ip对应的C类地址，相同的C类地址放在一起
// Make a list of unique class C's
unsigned char pchIPCMask[4] = { 0xff, 0xff, 0xff, 0x00 };
unsigned int nIPCMask = *(unsigned int*)pchIPCMask;
vector<unsigned int> vIPC;
CRITICAL_BLOCK(cs_mapAddresses)
{
vIPC.reserve(mapAddresses.size());
unsigned int nPrev = 0;
// mapAddress已经进行排序了，默认是生效排序
foreach(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
{
const CAddress& addr = item.second;
if (!addr.IsIPv4())
continue;
// Taking advantage of mapAddresses being in sorted order,
// with IPs of the same class C grouped together.
unsigned int ipC = addr.ip & nIPCMask;
if (ipC != nPrev)
vIPC.push_back(nPrev = ipC);
}
}
// IP选择的过程
// The IP selection process is designed to limit vulnerability致命性 to address flooding.
// Any class C (a.b.c.?) has an equal chance of being chosen, then an IP is
// chosen within the class C. An attacker may be able to allocate many IPs, but
// they would normally be concentrated in blocks of class C's. They can hog独占 the
// attention within their class C, but not the whole IP address space overall.
// A lone node in a class C will get as much attention as someone holding all 255
// IPs in another class C.
//
bool fSuccess = false;
int nLimit = vIPC.size();
while (!fSuccess && nLimit-- > 0)
{
// Choose a random class C 随机获取一个C级别的地址
unsigned int ipC = vIPC[GetRand(vIPC.size())];
// Organize all addresses in the class C by IP
map<unsigned int, vector3.4.2线程ThreadSocketHandler
线程ThreadSocketHandler对应的处理流程如下：
源码如下：
// socket 处理，parag对应的是本地节点开启的监听socket
void ThreadSocketHandler2(void* parg)
{
printf("ThreadSocketHandler started\n");
SOCKET hListenSocket = *(SOCKET*)parg; // 获得监听socket
list3.4.3线程ThreadMessageHandler
线程ThreadMessageHandler对应的处理流程：
源码如下：
// 消息处理线程
void ThreadMessageHandler2(void* parg)
{
printf("ThreadMessageHandler started\n");
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_BELOW_NORMAL);
loop
{
// 轮询链接的节点用于消息处理
// Poll the connected nodes for messages
vector pblock(new CBlock);
vRecv >> *pblock;
//// debug print
printf("received block:\n"); pblock->print();
CInv inv(MSG_BLOCK, pblock->GetHash());
pfrom->AddInventoryKnown(inv);// 增加库存
if (ProcessBlock(pfrom, pblock.release()))
mapAlreadyAskedFor.erase(inv);
}
else if (strCommand == "getaddr")
{
pfrom->vAddrToSend.clear();
//// need to expand the time range if not enough found
int64 nSince = GetAdjustedTime() - 60 * 60; // in the last hour 往前推一个小时
CRITICAL_BLOCK(cs_mapAddresses)
{
foreach(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
{
if (fShutdown)
return true;
const CAddress& addr = item.second;
if (addr.nTime > nSince)
pfrom->vAddrToSend.push_back(addr);
}
}
}
else if (strCommand == "checkorder")
{
uint256 hashReply;
CWalletTx order;
vRecv >> hashReply >> order;
/// we have a chance to check the order here
// Keep giving the same key to the same ip until they use it
if (!mapReuseKey.count(pfrom->addr.ip))
mapReuseKey[pfrom->addr.ip] = GenerateNewKey();
// Send back approval of order and pubkey to use
CScript scriptPubKey;
scriptPubKey << mapReuseKey[pfrom->addr.ip] << OP_CHECKSIG;
pfrom->PushMessage("reply", hashReply, (int)0, scriptPubKey);
}
else if (strCommand == "submitorder")
{
uint256 hashReply;
CWalletTx wtxNew;
vRecv >> hashReply >> wtxNew;
// Broadcast
if (!wtxNew.AcceptWalletTransaction())
{
pfrom->PushMessage("reply", hashReply, (int)1);
return error("submitorder AcceptWalletTransaction() failed, returning error 1");
}
wtxNew.fTimeReceivedIsTxTime = true;
AddToWallet(wtxNew);
wtxNew.RelayWalletTransaction();
mapReuseKey.erase(pfrom->addr.ip);
// Send back confirmation
pfrom->PushMessage("reply", hashReply, (int)0);
}
else if (strCommand == "reply")
{
uint256 hashReply;
vRecv >> hashReply;
CRequestTracker tracker;
CRITICAL_BLOCK(pfrom->cs_mapRequests)
{
map 3.5节点不同缓冲区
节点对应不同缓冲区的处理关系如下图所示：
3.6挖矿线程ThreadBitcoinMiner处理流程
挖矿处理流程如下图所示：
源码内容如下：
// 节点挖矿
bool BitcoinMiner()
{
printf("BitcoinMiner started\n");
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_LOWEST);
CKey key;
key.MakeNewKey(); // 使用椭圆曲线算法获得一对公钥和私钥
// 随机数从0开始
CBigNum bnExtraNonce = 0;
while (fGenerateBitcoins)
{
Sleep(50);
CheckForShutdown(3);
while (vNodes.empty())
{
Sleep(1000);
CheckForShutdown(3);
}
unsigned int nTransactionsUpdatedLast = nTransactionsUpdated;
CBlockIndex* pindexPrev = pindexBest;
// 获取挖矿难度
unsigned int nBits = GetNextWorkRequired(pindexPrev);
// 创建币基交易
// Create coinbase tx
//
CTransaction txNew;
txNew.vin.resize(1);
txNew.vin[0].prevout.SetNull();
txNew.vin[0].scriptSig << nBits << ++bnExtraNonce;
txNew.vout.resize(1);
txNew.vout[0].scriptPubKey << key.GetPubKey() << OP_CHECKSIG;
// 创建新的区块
// Create new block
//
auto_ptr pblock(new CBlock());
if (!pblock.get())
return false;
// 增加币基交易左右区块的第一个交易
// Add our coinbase tx as first transaction
pblock->vtx.push_back(txNew);
// 收集最新的交易放入区块中
// Collect the latest transactions into the block
int64 nFees = 0;
CRITICAL_BLOCK(cs_main)
CRITICAL_BLOCK(cs_mapTransactions)
{
CTxDB txdb("r");
map 4. 源码地址
我对比特币bitcoin-0.1.0源码加了详细的注释，对应的下载地址：https://github.com/lwjaiyjk/bitcoin-comment-0.1.0.git