src/blockencodings.h

   1 // Copyright (c) 2016 The Bitcoin Core developers
   2 // Distributed under the MIT software license, see the accompanying
   3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4
   5 #ifndef BITCOIN_BLOCK_ENCODINGS_H
   6 #define BITCOIN_BLOCK_ENCODINGS_H
   7
   8 #include "primitives/block.h"
   9
  10 #include <memory>
  11
  12 class CTxMemPool;
  13
  14 // Dumb helper to handle CTransaction compression at serialize-time
  15 struct TransactionCompressor {
  16 private:
  17     CTransactionRef& tx;
  18 public:
  19     TransactionCompressor(CTransactionRef& txIn) : tx(txIn) {}
  20
  21     ADD_SERIALIZE_METHODS;
  22
  23     template <typename Stream, typename Operation>
  24     inline void SerializationOp(Stream& s, Operation ser_action) {
  25         READWRITE(tx); //TODO: Compress tx encoding
  26     }
  27 };
  28
  29 class BlockTransactionsRequest {
  30 public:
  31     // A BlockTransactionsRequest message
  32     uint256 blockhash;
  33     std::vector<uint16_t> indexes;
  34
  35     ADD_SERIALIZE_METHODS;
  36
  37     template <typename Stream, typename Operation>
  38     inline void SerializationOp(Stream& s, Operation ser_action) {
  39         READWRITE(blockhash);
  40         uint64_t indexes_size = (uint64_t)indexes.size();
  41         READWRITE(COMPACTSIZE(indexes_size));
  42         if (ser_action.ForRead()) {
  43             size_t i = 0;
  44             while (indexes.size() < indexes_size) {
  45                 indexes.resize(std::min((uint64_t)(1000 + indexes.size()), indexes_size));
  46                 for (; i < indexes.size(); i++) {
  47                     uint64_t index = 0;
  48                     READWRITE(COMPACTSIZE(index));
  49                     if (index > std::numeric_limits<uint16_t>::max())
  50                         throw std::ios_base::failure("index overflowed 16 bits");
  51                     indexes[i] = index;
  52                 }
  53             }
  54
  55             uint16_t offset = 0;
  56             for (size_t j = 0; j < indexes.size(); j++) {
  57                 if (uint64_t(indexes[j]) + uint64_t(offset) > std::numeric_limits<uint16_t>::max())
  58                     throw std::ios_base::failure("indexes overflowed 16 bits");
  59                 indexes[j] = indexes[j] + offset;
  60                 offset = indexes[j] + 1;
  61             }
  62         } else {
  63             for (size_t i = 0; i < indexes.size(); i++) {
  64                 uint64_t index = indexes[i] - (i == 0 ? 0 : (indexes[i - 1] + 1));
  65                 READWRITE(COMPACTSIZE(index));
  66             }
  67         }
  68     }
  69 };
  70
  71 class BlockTransactions {
  72 public:
  73     // A BlockTransactions message
  74     uint256 blockhash;
  75     std::vector<CTransactionRef> txn;
  76
  77     BlockTransactions() {}
  78     BlockTransactions(const BlockTransactionsRequest& req) :
  79         blockhash(req.blockhash), txn(req.indexes.size()) {}
  80
  81     ADD_SERIALIZE_METHODS;
  82
  83     template <typename Stream, typename Operation>
  84     inline void SerializationOp(Stream& s, Operation ser_action) {
  85         READWRITE(blockhash);
  86         uint64_t txn_size = (uint64_t)txn.size();
  87         READWRITE(COMPACTSIZE(txn_size));
  88         if (ser_action.ForRead()) {
  89             size_t i = 0;
  90             while (txn.size() < txn_size) {
  91                 txn.resize(std::min((uint64_t)(1000 + txn.size()), txn_size));
  92                 for (; i < txn.size(); i++)
  93                     READWRITE(REF(TransactionCompressor(txn[i])));
  94             }
  95         } else {
  96             for (size_t i = 0; i < txn.size(); i++)
  97                 READWRITE(REF(TransactionCompressor(txn[i])));
  98         }
  99     }
 100 };
 101
 102 // Dumb serialization/storage-helper for CBlockHeaderAndShortTxIDs and PartiallyDownlaodedBlock
 103 struct PrefilledTransaction {
 104     // Used as an offset since last prefilled tx in CBlockHeaderAndShortTxIDs,
 105     // as a proper transaction-in-block-index in PartiallyDownloadedBlock
 106     uint16_t index;
 107     CTransactionRef tx;
 108
 109     ADD_SERIALIZE_METHODS;
 110
 111     template <typename Stream, typename Operation>
 112     inline void SerializationOp(Stream& s, Operation ser_action) {
 113         uint64_t idx = index;
 114         READWRITE(COMPACTSIZE(idx));
 115         if (idx > std::numeric_limits<uint16_t>::max())
 116             throw std::ios_base::failure("index overflowed 16-bits");
 117         index = idx;
 118         READWRITE(REF(TransactionCompressor(tx)));
 119     }
 120 };
 121
 122 typedef enum ReadStatus_t
 123 {
 124     READ_STATUS_OK,
 125     READ_STATUS_INVALID, // Invalid object, peer is sending bogus crap
 126     READ_STATUS_FAILED, // Failed to process object
 127     READ_STATUS_CHECKBLOCK_FAILED, // Used only by FillBlock to indicate a
 128                                    // failure in CheckBlock.
 129 } ReadStatus;
 130
 131 class CBlockHeaderAndShortTxIDs {
 132 private:
 133     mutable uint64_t shorttxidk0, shorttxidk1;
 134     uint64_t nonce;
 135
 136     void FillShortTxIDSelector() const;
 137
 138     friend class PartiallyDownloadedBlock;
 139
 140     static const int SHORTTXIDS_LENGTH = 6;
 141 protected:
 142     std::vector<uint64_t> shorttxids;
 143     std::vector<PrefilledTransaction> prefilledtxn;
 144
 145 public:
 146     CBlockHeader header;
 147
 148     // Dummy for deserialization
 149     CBlockHeaderAndShortTxIDs() {}
 150
 151     CBlockHeaderAndShortTxIDs(const CBlock& block, bool fUseWTXID);
 152
 153     uint64_t GetShortID(const uint256& txhash) const;
 154
 155     size_t BlockTxCount() const { return shorttxids.size() + prefilledtxn.size(); }
 156
 157     ADD_SERIALIZE_METHODS;
 158
 159     template <typename Stream, typename Operation>
 160     inline void SerializationOp(Stream& s, Operation ser_action) {
 161         READWRITE(header);
 162         READWRITE(nonce);
 163
 164         uint64_t shorttxids_size = (uint64_t)shorttxids.size();
 165         READWRITE(COMPACTSIZE(shorttxids_size));
 166         if (ser_action.ForRead()) {
 167             size_t i = 0;
 168             while (shorttxids.size() < shorttxids_size) {
 169                 shorttxids.resize(std::min((uint64_t)(1000 + shorttxids.size()), shorttxids_size));
 170                 for (; i < shorttxids.size(); i++) {
 171                     uint32_t lsb = 0; uint16_t msb = 0;
 172                     READWRITE(lsb);
 173                     READWRITE(msb);
 174                     shorttxids[i] = (uint64_t(msb) << 32) | uint64_t(lsb);
 175                     static_assert(SHORTTXIDS_LENGTH == 6, "shorttxids serialization assumes 6-byte shorttxids");
 176                 }
 177             }
 178         } else {
 179             for (size_t i = 0; i < shorttxids.size(); i++) {
 180                 uint32_t lsb = shorttxids[i] & 0xffffffff;
 181                 uint16_t msb = (shorttxids[i] >> 32) & 0xffff;
 182                 READWRITE(lsb);
 183                 READWRITE(msb);
 184             }
 185         }
 186
 187         READWRITE(prefilledtxn);
 188
 189         if (ser_action.ForRead())
 190             FillShortTxIDSelector();
 191     }
 192 };
 193
 194 class PartiallyDownloadedBlock {
 195 protected:
 196     std::vector<CTransactionRef> txn_available;
 197     size_t prefilled_count = 0, mempool_count = 0;
 198     CTxMemPool* pool;
 199 public:
 200     CBlockHeader header;
 201     PartiallyDownloadedBlock(CTxMemPool* poolIn) : pool(poolIn) {}
 202
 203     ReadStatus InitData(const CBlockHeaderAndShortTxIDs& cmpctblock);
 204     bool IsTxAvailable(size_t index) const;
 205     ReadStatus FillBlock(CBlock& block, const std::vector<CTransactionRef>& vtx_missing) const;
 206 };
 207
 208 #endif