merkleblock.h

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core 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 <common/bloom.h>
#include <primitives/block.h>
#include <serialize.h>
#include <uint256.h>
 
#include <vector>
 
// Helper functions for serialization.
std::vector<uint8_t> BitsToBytes(const std::vector<bool> &bits);
std::vector<bool> BytesToBits(const std::vector<uint8_t> &bytes);
 
class CPartialMerkleTree {
protected:
    uint32_t nTransactions;
 
    std::vector<bool> vBits;
 
    std::vector<uint256> vHash;
 
    bool fBad;
 
    size_t CalcTreeWidth(int height) const {
        return (nTransactions + (1 << height) - 1) >> height;
    }
 
    uint256 CalcHash(int height, size_t pos, const std::vector<uint256> &vTxid);
 
    void TraverseAndBuild(int height, size_t pos,
                          const std::vector<uint256> &vTxid,
                          const std::vector<bool> &vMatch);
 
    uint256 TraverseAndExtract(int height, size_t pos, size_t &nBitsUsed,
                               size_t &nHashUsed, std::vector<uint256> &vMatch,
                               std::vector<size_t> &vnIndex);
 
public:
    SERIALIZE_METHODS(CPartialMerkleTree, obj) {
        READWRITE(obj.nTransactions, obj.vHash);
        std::vector<uint8_t> bytes;
        SER_WRITE(obj, bytes = BitsToBytes(obj.vBits));
        READWRITE(bytes);
        SER_READ(obj, obj.vBits = BytesToBits(bytes));
        SER_READ(obj, obj.fBad = false);
    }
 
    CPartialMerkleTree(const std::vector<uint256> &vTxid,
                       const std::vector<bool> &vMatch);
 
    CPartialMerkleTree();
 
    uint256 ExtractMatches(std::vector<uint256> &vMatch,
                           std::vector<size_t> &vnIndex);
 
    uint32_t GetNumTransactions() const { return nTransactions; };
};
 
class CMerkleBlock {
public:
    CBlockHeader header;
    CPartialMerkleTree txn;
 
    std::vector<std::pair<size_t, uint256>> vMatchedTxn;
 
    CMerkleBlock(const CBlock &block, CBloomFilter &filter)
        : CMerkleBlock(block, &filter, nullptr) {}
 
    CMerkleBlock(const CBlock &block, const std::set<TxId> &txids)
        : CMerkleBlock(block, nullptr, &txids) {}
 
    CMerkleBlock() {}
 
    SERIALIZE_METHODS(CMerkleBlock, obj) { READWRITE(obj.header, obj.txn); }
 
private:
    CMerkleBlock(const CBlock &block, CBloomFilter *filter,
                 const std::set<TxId> *txids);
};
 
#endif // BITCOIN_MERKLEBLOCK_H