Bitcoin Core  24.99.0
P2P Digital Currency
blockencodings.h
Go to the documentation of this file.
1 // Copyright (c) 2016-2022 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_BLOCKENCODINGS_H
6 #define BITCOIN_BLOCKENCODINGS_H
7 
8 #include <primitives/block.h>
9 
10 #include <functional>
11 
12 class CTxMemPool;
14 namespace Consensus {
15 struct Params;
16 };
17 
18 // Transaction compression schemes for compact block relay can be introduced by writing
19 // an actual formatter here.
21 
23 {
24  uint64_t m_shift = 0;
25 
26 public:
27  template<typename Stream, typename I>
28  void Ser(Stream& s, I v)
29  {
30  if (v < m_shift || v >= std::numeric_limits<uint64_t>::max()) throw std::ios_base::failure("differential value overflow");
31  WriteCompactSize(s, v - m_shift);
32  m_shift = uint64_t(v) + 1;
33  }
34  template<typename Stream, typename I>
35  void Unser(Stream& s, I& v)
36  {
37  uint64_t n = ReadCompactSize(s);
38  m_shift += n;
39  if (m_shift < n || m_shift >= std::numeric_limits<uint64_t>::max() || m_shift < std::numeric_limits<I>::min() || m_shift > std::numeric_limits<I>::max()) throw std::ios_base::failure("differential value overflow");
40  v = I(m_shift++);
41  }
42 };
43 
45 public:
46  // A BlockTransactionsRequest message
48  std::vector<uint16_t> indexes;
49 
51  {
52  READWRITE(obj.blockhash, Using<VectorFormatter<DifferenceFormatter>>(obj.indexes));
53  }
54 };
55 
57 public:
58  // A BlockTransactions message
60  std::vector<CTransactionRef> txn;
61 
64  blockhash(req.blockhash), txn(req.indexes.size()) {}
65 
67  {
69  }
70 };
71 
72 // Dumb serialization/storage-helper for CBlockHeaderAndShortTxIDs and PartiallyDownloadedBlock
74  // Used as an offset since last prefilled tx in CBlockHeaderAndShortTxIDs,
75  // as a proper transaction-in-block-index in PartiallyDownloadedBlock
76  uint16_t index;
78 
79  SERIALIZE_METHODS(PrefilledTransaction, obj) { READWRITE(COMPACTSIZE(obj.index), Using<TransactionCompression>(obj.tx)); }
80 };
81 
82 typedef enum ReadStatus_t
83 {
85  READ_STATUS_INVALID, // Invalid object, peer is sending bogus crap
86  READ_STATUS_FAILED, // Failed to process object
87  READ_STATUS_CHECKBLOCK_FAILED, // Used only by FillBlock to indicate a
88  // failure in CheckBlock.
90 
92 private:
93  mutable uint64_t shorttxidk0, shorttxidk1;
94  uint64_t nonce;
95 
96  void FillShortTxIDSelector() const;
97 
99 
100 protected:
101  std::vector<uint64_t> shorttxids;
102  std::vector<PrefilledTransaction> prefilledtxn;
103 
104 public:
105  static constexpr int SHORTTXIDS_LENGTH = 6;
106 
108 
109  // Dummy for deserialization
111 
112  CBlockHeaderAndShortTxIDs(const CBlock& block);
113 
114  uint64_t GetShortID(const uint256& txhash) const;
115 
116  size_t BlockTxCount() const { return shorttxids.size() + prefilledtxn.size(); }
117 
119  {
120  READWRITE(obj.header, obj.nonce, Using<VectorFormatter<CustomUintFormatter<SHORTTXIDS_LENGTH>>>(obj.shorttxids), obj.prefilledtxn);
121  if (ser_action.ForRead()) {
122  if (obj.BlockTxCount() > std::numeric_limits<uint16_t>::max()) {
123  throw std::ios_base::failure("indexes overflowed 16 bits");
124  }
125  obj.FillShortTxIDSelector();
126  }
127  }
128 };
129 
131 protected:
132  std::vector<CTransactionRef> txn_available;
134  const CTxMemPool* pool;
135 public:
137 
138  // Can be overriden for testing
139  using CheckBlockFn = std::function<bool(const CBlock&, BlockValidationState&, const Consensus::Params&, bool, bool)>;
141 
142  explicit PartiallyDownloadedBlock(CTxMemPool* poolIn) : pool(poolIn) {}
143 
144  // extra_txn is a list of extra transactions to look at, in <witness hash, reference> form
145  ReadStatus InitData(const CBlockHeaderAndShortTxIDs& cmpctblock, const std::vector<std::pair<uint256, CTransactionRef>>& extra_txn);
146  bool IsTxAvailable(size_t index) const;
147  ReadStatus FillBlock(CBlock& block, const std::vector<CTransactionRef>& vtx_missing);
148 };
149 
150 #endif // BITCOIN_BLOCKENCODINGS_H
ReadStatus_t
@ READ_STATUS_OK
@ READ_STATUS_INVALID
@ READ_STATUS_CHECKBLOCK_FAILED
@ READ_STATUS_FAILED
enum ReadStatus_t ReadStatus
std::vector< std::pair< uint256, CTransactionRef > > extra_txn
std::vector< CTransactionRef > txn
BlockTransactions(const BlockTransactionsRequest &req)
SERIALIZE_METHODS(BlockTransactions, obj)
SERIALIZE_METHODS(BlockTransactionsRequest, obj)
std::vector< uint16_t > indexes
void FillShortTxIDSelector() const
SERIALIZE_METHODS(CBlockHeaderAndShortTxIDs, obj)
std::vector< PrefilledTransaction > prefilledtxn
uint64_t GetShortID(const uint256 &txhash) const
static constexpr int SHORTTXIDS_LENGTH
std::vector< uint64_t > shorttxids
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition: block.h:22
Definition: block.h:69
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:316
void Unser(Stream &s, I &v)
void Ser(Stream &s, I v)
ReadStatus InitData(const CBlockHeaderAndShortTxIDs &cmpctblock, const std::vector< std::pair< uint256, CTransactionRef >> &extra_txn)
PartiallyDownloadedBlock(CTxMemPool *poolIn)
const CTxMemPool * pool
CheckBlockFn m_check_block_mock
std::vector< CTransactionRef > txn_available
bool IsTxAvailable(size_t index) const
ReadStatus FillBlock(CBlock &block, const std::vector< CTransactionRef > &vtx_missing)
std::function< bool(const CBlock &, BlockValidationState &, const Consensus::Params &, bool, bool)> CheckBlockFn
256-bit opaque blob.
Definition: uint256.h:119
Transaction validation functions.
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:421
static Wrapper< Formatter, T & > Using(T &&t)
Cause serialization/deserialization of an object to be done using a specified formatter class.
Definition: serialize.h:433
uint64_t ReadCompactSize(Stream &is, bool range_check=true)
Decode a CompactSize-encoded variable-length integer.
Definition: serialize.h:275
#define COMPACTSIZE(obj)
Definition: serialize.h:437
#define READWRITE(...)
Definition: serialize.h:140
void WriteCompactSize(CSizeComputer &os, uint64_t nSize)
Definition: serialize.h:1103
Parameters that influence chain consensus.
Definition: params.h:73
Serialization wrapper class for custom integers and enums.
Definition: serialize.h:466
Default formatter.
Definition: serialize.h:714
SERIALIZE_METHODS(PrefilledTransaction, obj)
CTransactionRef tx
Formatter to serialize/deserialize vector elements using another formatter.
Definition: serialize.h:595