Browse Source
afd4b94 Move CMerkleBlock and CPartialMerkleTree to their own file (Matt Corallo)
Wladimir J. van der Laan
10 years ago
9 changed files with 318 additions and 294 deletions
@ -0,0 +1,152 @@
@@ -0,0 +1,152 @@
|
||||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2014 The Bitcoin developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include "merkleblock.h" |
||||
|
||||
#include "hash.h" |
||||
#include "primitives/block.h" // for MAX_BLOCK_SIZE |
||||
#include "utilstrencodings.h" |
||||
|
||||
using namespace std; |
||||
|
||||
CMerkleBlock::CMerkleBlock(const CBlock& block, CBloomFilter& filter) |
||||
{ |
||||
header = block.GetBlockHeader(); |
||||
|
||||
vector<bool> vMatch; |
||||
vector<uint256> vHashes; |
||||
|
||||
vMatch.reserve(block.vtx.size()); |
||||
vHashes.reserve(block.vtx.size()); |
||||
|
||||
for (unsigned int i = 0; i < block.vtx.size(); i++) |
||||
{ |
||||
const uint256& hash = block.vtx[i].GetHash(); |
||||
if (filter.IsRelevantAndUpdate(block.vtx[i])) |
||||
{ |
||||
vMatch.push_back(true); |
||||
vMatchedTxn.push_back(make_pair(i, hash)); |
||||
} |
||||
else |
||||
vMatch.push_back(false); |
||||
vHashes.push_back(hash); |
||||
} |
||||
|
||||
txn = CPartialMerkleTree(vHashes, vMatch); |
||||
} |
||||
|
||||
uint256 CPartialMerkleTree::CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid) { |
||||
if (height == 0) { |
||||
// hash at height 0 is the txids themself
|
||||
return vTxid[pos]; |
||||
} else { |
||||
// calculate left hash
|
||||
uint256 left = CalcHash(height-1, pos*2, vTxid), right; |
||||
// calculate right hash if not beyond the end of the array - copy left hash otherwise1
|
||||
if (pos*2+1 < CalcTreeWidth(height-1)) |
||||
right = CalcHash(height-1, pos*2+1, vTxid); |
||||
else |
||||
right = left; |
||||
// combine subhashes
|
||||
return Hash(BEGIN(left), END(left), BEGIN(right), END(right)); |
||||
} |
||||
} |
||||
|
||||
void CPartialMerkleTree::TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch) { |
||||
// determine whether this node is the parent of at least one matched txid
|
||||
bool fParentOfMatch = false; |
||||
for (unsigned int p = pos << height; p < (pos+1) << height && p < nTransactions; p++) |
||||
fParentOfMatch |= vMatch[p]; |
||||
// store as flag bit
|
||||
vBits.push_back(fParentOfMatch); |
||||
if (height==0 || !fParentOfMatch) { |
||||
// if at height 0, or nothing interesting below, store hash and stop
|
||||
vHash.push_back(CalcHash(height, pos, vTxid)); |
||||
} else { |
||||
// otherwise, don't store any hash, but descend into the subtrees
|
||||
TraverseAndBuild(height-1, pos*2, vTxid, vMatch); |
||||
if (pos*2+1 < CalcTreeWidth(height-1)) |
||||
TraverseAndBuild(height-1, pos*2+1, vTxid, vMatch); |
||||
} |
||||
} |
||||
|
||||
uint256 CPartialMerkleTree::TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch) { |
||||
if (nBitsUsed >= vBits.size()) { |
||||
// overflowed the bits array - failure
|
||||
fBad = true; |
||||
return 0; |
||||
} |
||||
bool fParentOfMatch = vBits[nBitsUsed++]; |
||||
if (height==0 || !fParentOfMatch) { |
||||
// if at height 0, or nothing interesting below, use stored hash and do not descend
|
||||
if (nHashUsed >= vHash.size()) { |
||||
// overflowed the hash array - failure
|
||||
fBad = true; |
||||
return 0; |
||||
} |
||||
const uint256 &hash = vHash[nHashUsed++]; |
||||
if (height==0 && fParentOfMatch) // in case of height 0, we have a matched txid
|
||||
vMatch.push_back(hash); |
||||
return hash; |
||||
} else { |
||||
// otherwise, descend into the subtrees to extract matched txids and hashes
|
||||
uint256 left = TraverseAndExtract(height-1, pos*2, nBitsUsed, nHashUsed, vMatch), right; |
||||
if (pos*2+1 < CalcTreeWidth(height-1)) |
||||
right = TraverseAndExtract(height-1, pos*2+1, nBitsUsed, nHashUsed, vMatch); |
||||
else |
||||
right = left; |
||||
// and combine them before returning
|
||||
return Hash(BEGIN(left), END(left), BEGIN(right), END(right)); |
||||
} |
||||
} |
||||
|
||||
CPartialMerkleTree::CPartialMerkleTree(const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch) : nTransactions(vTxid.size()), fBad(false) { |
||||
// reset state
|
||||
vBits.clear(); |
||||
vHash.clear(); |
||||
|
||||
// calculate height of tree
|
||||
int nHeight = 0; |
||||
while (CalcTreeWidth(nHeight) > 1) |
||||
nHeight++; |
||||
|
||||
// traverse the partial tree
|
||||
TraverseAndBuild(nHeight, 0, vTxid, vMatch); |
||||
} |
||||
|
||||
CPartialMerkleTree::CPartialMerkleTree() : nTransactions(0), fBad(true) {} |
||||
|
||||
uint256 CPartialMerkleTree::ExtractMatches(std::vector<uint256> &vMatch) { |
||||
vMatch.clear(); |
||||
// An empty set will not work
|
||||
if (nTransactions == 0) |
||||
return 0; |
||||
// check for excessively high numbers of transactions
|
||||
if (nTransactions > MAX_BLOCK_SIZE / 60) // 60 is the lower bound for the size of a serialized CTransaction
|
||||
return 0; |
||||
// there can never be more hashes provided than one for every txid
|
||||
if (vHash.size() > nTransactions) |
||||
return 0; |
||||
// there must be at least one bit per node in the partial tree, and at least one node per hash
|
||||
if (vBits.size() < vHash.size()) |
||||
return 0; |
||||
// calculate height of tree
|
||||
int nHeight = 0; |
||||
while (CalcTreeWidth(nHeight) > 1) |
||||
nHeight++; |
||||
// traverse the partial tree
|
||||
unsigned int nBitsUsed = 0, nHashUsed = 0; |
||||
uint256 hashMerkleRoot = TraverseAndExtract(nHeight, 0, nBitsUsed, nHashUsed, vMatch); |
||||
// verify that no problems occured during the tree traversal
|
||||
if (fBad) |
||||
return 0; |
||||
// verify that all bits were consumed (except for the padding caused by serializing it as a byte sequence)
|
||||
if ((nBitsUsed+7)/8 != (vBits.size()+7)/8) |
||||
return 0; |
||||
// verify that all hashes were consumed
|
||||
if (nHashUsed != vHash.size()) |
||||
return 0; |
||||
return hashMerkleRoot; |
||||
} |
||||
@ -0,0 +1,151 @@
@@ -0,0 +1,151 @@
|
||||
// Copyright (c) 2009-2010 Satoshi Nakamoto
|
||||
// Copyright (c) 2009-2014 The Bitcoin developers
|
||||
// Distributed under the MIT software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#ifndef BITCOIN_MERKLEBLOCK_H |
||||
#define BITCOIN_MERKLEBLOCK_H |
||||
|
||||
#include "serialize.h" |
||||
#include "uint256.h" |
||||
#include "primitives/block.h" |
||||
#include "bloom.h" |
||||
|
||||
#include <vector> |
||||
|
||||
/** Data structure that represents a partial merkle tree.
|
||||
* |
||||
* It represents a subset of the txid's of a known block, in a way that |
||||
* allows recovery of the list of txid's and the merkle root, in an |
||||
* authenticated way. |
||||
* |
||||
* The encoding works as follows: we traverse the tree in depth-first order, |
||||
* storing a bit for each traversed node, signifying whether the node is the |
||||
* parent of at least one matched leaf txid (or a matched txid itself). In |
||||
* case we are at the leaf level, or this bit is 0, its merkle node hash is |
||||
* stored, and its children are not explorer further. Otherwise, no hash is |
||||
* stored, but we recurse into both (or the only) child branch. During |
||||
* decoding, the same depth-first traversal is performed, consuming bits and |
||||
* hashes as they written during encoding. |
||||
* |
||||
* The serialization is fixed and provides a hard guarantee about the |
||||
* encoded size: |
||||
* |
||||
* SIZE <= 10 + ceil(32.25*N) |
||||
* |
||||
* Where N represents the number of leaf nodes of the partial tree. N itself |
||||
* is bounded by: |
||||
* |
||||
* N <= total_transactions |
||||
* N <= 1 + matched_transactions*tree_height |
||||
* |
||||
* The serialization format: |
||||
* - uint32 total_transactions (4 bytes) |
||||
* - varint number of hashes (1-3 bytes) |
||||
* - uint256[] hashes in depth-first order (<= 32*N bytes) |
||||
* - varint number of bytes of flag bits (1-3 bytes) |
||||
* - byte[] flag bits, packed per 8 in a byte, least significant bit first (<= 2*N-1 bits) |
||||
* The size constraints follow from this. |
||||
*/ |
||||
class CPartialMerkleTree |
||||
{ |
||||
protected: |
||||
/** the total number of transactions in the block */ |
||||
unsigned int nTransactions; |
||||
|
||||
/** node-is-parent-of-matched-txid bits */ |
||||
std::vector<bool> vBits; |
||||
|
||||
/** txids and internal hashes */ |
||||
std::vector<uint256> vHash; |
||||
|
||||
/** flag set when encountering invalid data */ |
||||
bool fBad; |
||||
|
||||
/** helper function to efficiently calculate the number of nodes at given height in the merkle tree */ |
||||
unsigned int CalcTreeWidth(int height) { |
||||
return (nTransactions+(1 << height)-1) >> height; |
||||
} |
||||
|
||||
/** calculate the hash of a node in the merkle tree (at leaf level: the txid's themselves) */ |
||||
uint256 CalcHash(int height, unsigned int pos, const std::vector<uint256> &vTxid); |
||||
|
||||
/** recursive function that traverses tree nodes, storing the data as bits and hashes */ |
||||
void TraverseAndBuild(int height, unsigned int pos, const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch); |
||||
|
||||
/**
|
||||
* recursive function that traverses tree nodes, consuming the bits and hashes produced by TraverseAndBuild. |
||||
* it returns the hash of the respective node. |
||||
*/ |
||||
uint256 TraverseAndExtract(int height, unsigned int pos, unsigned int &nBitsUsed, unsigned int &nHashUsed, std::vector<uint256> &vMatch); |
||||
|
||||
public: |
||||
|
||||
/** serialization implementation */ |
||||
ADD_SERIALIZE_METHODS; |
||||
|
||||
template <typename Stream, typename Operation> |
||||
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { |
||||
READWRITE(nTransactions); |
||||
READWRITE(vHash); |
||||
std::vector<unsigned char> vBytes; |
||||
if (ser_action.ForRead()) { |
||||
READWRITE(vBytes); |
||||
CPartialMerkleTree &us = *(const_cast<CPartialMerkleTree*>(this)); |
||||
us.vBits.resize(vBytes.size() * 8); |
||||
for (unsigned int p = 0; p < us.vBits.size(); p++) |
||||
us.vBits[p] = (vBytes[p / 8] & (1 << (p % 8))) != 0; |
||||
us.fBad = false; |
||||
} else { |
||||
vBytes.resize((vBits.size()+7)/8); |
||||
for (unsigned int p = 0; p < vBits.size(); p++) |
||||
vBytes[p / 8] |= vBits[p] << (p % 8); |
||||
READWRITE(vBytes); |
||||
} |
||||
} |
||||
|
||||
/** Construct a partial merkle tree from a list of transaction id's, and a mask that selects a subset of them */ |
||||
CPartialMerkleTree(const std::vector<uint256> &vTxid, const std::vector<bool> &vMatch); |
||||
|
||||
CPartialMerkleTree(); |
||||
|
||||
/**
|
||||
* extract the matching txid's represented by this partial merkle tree. |
||||
* returns the merkle root, or 0 in case of failure |
||||
*/ |
||||
uint256 ExtractMatches(std::vector<uint256> &vMatch); |
||||
}; |
||||
|
||||
|
||||
/**
|
||||
* Used to relay blocks as header + vector<merkle branch> |
||||
* to filtered nodes. |
||||
*/ |
||||
class CMerkleBlock |
||||
{ |
||||
public: |
||||
/** Public only for unit testing */ |
||||
CBlockHeader header; |
||||
CPartialMerkleTree txn; |
||||
|
||||
public: |
||||
/** Public only for unit testing and relay testing (not relayed) */ |
||||
std::vector<std::pair<unsigned int, uint256> > vMatchedTxn; |
||||
|
||||
/**
|
||||
* Create from a CBlock, filtering transactions according to filter |
||||
* Note that this will call IsRelevantAndUpdate on the filter for each transaction, |
||||
* thus the filter will likely be modified. |
||||
*/ |
||||
CMerkleBlock(const CBlock& block, CBloomFilter& filter); |
||||
|
||||
ADD_SERIALIZE_METHODS; |
||||
|
||||
template <typename Stream, typename Operation> |
||||
inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) { |
||||
READWRITE(header); |
||||
READWRITE(txn); |
||||
} |
||||
}; |
||||
|
||||
#endif // BITCOIN_MERKLEBLOCK_H
|
||||
Loading…
Reference in new issue