Bitcoin ABC 0.31.6
P2P Digital Currency
processor.h
Go to the documentation of this file.
1// Copyright (c) 2018-2019 The Bitcoin 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_AVALANCHE_PROCESSOR_H
6#define BITCOIN_AVALANCHE_PROCESSOR_H
7
8#include <avalanche/config.h>
9#include <avalanche/node.h>
10#include <avalanche/proof.h>
12#include <avalanche/protocol.h>
14#include <avalanche/voterecord.h> // For AVALANCHE_MAX_INFLIGHT_POLL
15#include <blockindex.h>
17#include <common/bloom.h>
18#include <eventloop.h>
19#include <interfaces/chain.h>
20#include <interfaces/handler.h>
21#include <key.h>
22#include <net.h>
24#include <rwcollection.h>
25#include <txmempool.h>
26#include <util/variant.h>
27#include <validationinterface.h>
28
29#include <boost/multi_index/composite_key.hpp>
30#include <boost/multi_index/hashed_index.hpp>
31#include <boost/multi_index/member.hpp>
32#include <boost/multi_index/ordered_index.hpp>
33#include <boost/multi_index_container.hpp>
34
35#include <atomic>
36#include <chrono>
37#include <cstdint>
38#include <memory>
39#include <unordered_map>
40#include <variant>
41#include <vector>
42
43class ArgsManager;
44class CConnman;
45class CNode;
46class CScheduler;
47class Config;
48class PeerManager;
49struct bilingual_str;
50
54static constexpr size_t AVALANCHE_MAX_ELEMENT_POLL = 16;
55
60static constexpr size_t AVALANCHE_CONTENDER_MAX_POLLABLE = 12;
61
65static constexpr std::chrono::milliseconds AVALANCHE_DEFAULT_QUERY_TIMEOUT{
66 10000};
67
78
79namespace avalanche {
80
81class Delegation;
82class PeerManager;
83class ProofRegistrationState;
84struct VoteRecord;
85
86enum struct VoteStatus : uint8_t {
87 Invalid,
91 Stale,
92};
93
94using AnyVoteItem = std::variant<const ProofRef, const CBlockIndex *,
96
100
101public:
103 : item(std::move(itemIn)), status(statusIn) {}
104
105 const VoteStatus &getStatus() const { return status; }
106 const AnyVoteItem &getVoteItem() const { return item; }
107};
108
110 bool operator()(const AnyVoteItem &lhs, const AnyVoteItem &rhs) const {
111 // If the variants are of different types, sort them by variant index
112 if (lhs.index() != rhs.index()) {
113 return lhs.index() < rhs.index();
114 }
115
116 return std::visit(
118 [](const ProofRef &lhs, const ProofRef &rhs) {
119 return ProofComparatorByScore()(lhs, rhs);
120 },
121 [](const CBlockIndex *lhs, const CBlockIndex *rhs) {
122 // Reverse ordering so we get the highest work first
123 return CBlockIndexWorkComparator()(rhs, lhs);
124 },
125 [](const StakeContenderId &lhs, const StakeContenderId &rhs) {
126 return lhs < rhs;
127 },
128 [](const CTransactionRef &lhs, const CTransactionRef &rhs) {
129 return lhs->GetId() < rhs->GetId();
130 },
131 [](const auto &lhs, const auto &rhs) {
132 // This serves 2 purposes:
133 // - This makes sure that we don't forget to implement a
134 // comparison case when adding a new variant type.
135 // - This avoids having to write all the cross type cases
136 // which are already handled by the index sort above.
137 // Because the compiler has no way to determine that, we
138 // cannot use static assertions here without having to
139 // define the whole type matrix also.
140 assert(false);
141 // Return any bool, it's only there to make the compiler
142 // happy.
143 return false;
144 },
145 },
146 lhs, rhs);
147 }
148};
149using VoteMap = std::map<AnyVoteItem, VoteRecord, VoteMapComparator>;
150
152
153namespace {
154 struct AvalancheTest;
155}
156
157// FIXME Implement a proper notification handler for node disconnection instead
158// of implementing the whole NetEventsInterface for a single interesting event.
159class Processor final : public NetEventsInterface {
164
169
173 std::atomic<uint64_t> round;
174
179 std::unique_ptr<PeerManager> peerManager GUARDED_BY(cs_peerManager);
180
181 struct Query {
183 uint64_t round;
185
192 mutable std::vector<CInv> invs;
193 };
194
195 using QuerySet = boost::multi_index_container<
196 Query,
197 boost::multi_index::indexed_by<
198 // index by nodeid/round
199 boost::multi_index::hashed_unique<boost::multi_index::composite_key<
200 Query,
201 boost::multi_index::member<Query, NodeId, &Query::nodeid>,
202 boost::multi_index::member<Query, uint64_t, &Query::round>>>,
203 // sorted by timeout
204 boost::multi_index::ordered_non_unique<
205 boost::multi_index::tag<query_timeout>,
206 boost::multi_index::member<Query, SteadyMilliseconds,
207 &Query::timeout>>>>;
208
210
212 struct PeerData;
213 std::unique_ptr<PeerData> peerData;
215
218
224 std::atomic<bool> quorumIsEstablished{false};
225 std::atomic<bool> m_canShareLocalProof{false};
227 std::atomic<int64_t> avaproofsNodeCounter{0};
228
230 const uint32_t staleVoteThreshold;
231 const uint32_t staleVoteFactor;
232
235 std::unique_ptr<interfaces::Handler> chainNotificationsHandler;
236
238 const CBlockIndex *finalizationTip GUARDED_BY(cs_finalizationTip){nullptr};
239
245 std::unordered_set<NodeId>
246 delayedAvahelloNodeIds GUARDED_BY(cs_delayedAvahelloNodeIds);
247
250 // Ordered list of acceptable winners, only the first is used for mining
251 std::vector<std::pair<ProofId, CScript>> winners;
252 };
253
255 std::unordered_map<BlockHash, StakingReward, SaltedUint256Hasher>
257
260 CScheduler &scheduler, std::unique_ptr<PeerData> peerDataIn,
261 CKey sessionKeyIn, uint32_t minQuorumTotalScoreIn,
262 double minQuorumConnectedScoreRatioIn,
263 int64_t minAvaproofsNodeCountIn, uint32_t staleVoteThresholdIn,
264 uint32_t staleVoteFactorIn, Amount stakeUtxoDustThresholdIn,
265 bool preConsensus, bool stakingPreConsensus);
266
267public:
268 const bool m_preConsensus{false};
269 const bool m_stakingPreConsensus{false};
270
271 ~Processor();
272
273 static std::unique_ptr<Processor>
274 MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain,
276 CTxMemPool *mempoolIn, CScheduler &scheduler,
278
279 bool addToReconcile(const AnyVoteItem &item)
286 bool reconcileOrFinalize(const ProofRef &proof)
288 bool isAccepted(const AnyVoteItem &item) const;
289 int getConfidence(const AnyVoteItem &item) const;
290 bool isPolled(const AnyVoteItem &item) const;
291
292 bool isRecentlyFinalized(const uint256 &itemId) const
294 void setRecentlyFinalized(const uint256 &itemId)
297
298 // TODO: Refactor the API to remove the dependency on avalanche/protocol.h
299 void sendResponse(CNode *pfrom, Response response) const;
300 bool registerVotes(NodeId nodeid, const Response &response,
301 std::vector<VoteItemUpdate> &updates, bool &disconnect,
302 std::string &error)
305
306 template <typename Callable>
307 auto withPeerManager(Callable &&func) const
310 return func(*peerManager);
311 }
312
320 bool sendHello(CNode *pfrom)
324
325 ProofRef getLocalProof() const;
327
328 /*
329 * Return whether the avalanche service flag should be set.
330 */
332
336 return finalizationTip != nullptr;
337 }
338
339 bool startEventLoop(CScheduler &scheduler);
340 bool stopEventLoop();
341
344 int64_t getAvaproofsNodeCounter() const {
345 return avaproofsNodeCounter.load();
346 }
350 bool canShareLocalProof();
351
352 bool computeStakingReward(const CBlockIndex *pindex)
355 bool eraseStakingRewardWinner(const BlockHash &prevBlockHash)
357 void cleanupStakingRewards(const int minHeight)
360 const BlockHash &prevBlockHash,
361 std::vector<std::pair<ProofId, CScript>> &winners) const
363 bool getStakingRewardWinners(const BlockHash &prevBlockHash,
364 std::vector<CScript> &payouts) const
366 bool setStakingRewardWinners(const CBlockIndex *pprev,
367 const std::vector<CScript> &payouts)
370 const CBlockIndex *pprev,
371 const std::vector<std::pair<ProofId, CScript>> &winners)
373
374 // Implement NetEventInterface. Only FinalizeNode is of interest.
375 void InitializeNode(const ::Config &config, CNode &pnode,
376 ServiceFlags our_services) override {}
377 bool ProcessMessages(const ::Config &config, CNode *pnode,
378 std::atomic<bool> &interrupt) override {
379 return false;
380 }
381 bool SendMessages(const ::Config &config, CNode *pnode) override {
382 return false;
383 }
384
386 void FinalizeNode(const ::Config &config,
387 const CNode &node) override LOCKS_EXCLUDED(cs_main)
389
391 int getStakeContenderStatus(const StakeContenderId &contenderId) const
393 void acceptStakeContender(const StakeContenderId &contenderId)
395 void finalizeStakeContender(const StakeContenderId &contenderId)
397 void rejectStakeContender(const StakeContenderId &contenderId)
399
404
405private:
406 void updatedBlockTip()
411 void runEventLoop()
415 std::vector<CInv> getInvsForNextPoll(bool forPoll = true)
417 bool sendHelloInternal(CNode *pfrom)
419 AnyVoteItem getVoteItemFromInv(const CInv &inv) const
421
428 const CBlockIndex *pindex,
429 std::vector<StakeContenderId> &pollableContenders)
431
440 100, 0.0000001};
441
454
457
458 IsWorthPolling(const Processor &_processor) : processor(_processor){};
459
460 bool operator()(const CBlockIndex *pindex) const
462 bool operator()(const ProofRef &proof) const
464 bool operator()(const StakeContenderId &contenderId) const
466 bool operator()(const CTransactionRef &tx) const;
467 };
468 bool isWorthPolling(const AnyVoteItem &item) const
470
473
474 GetLocalAcceptance(const Processor &_processor)
475 : processor(_processor){};
476
477 bool operator()(const CBlockIndex *pindex) const
479 bool operator()(const ProofRef &proof) const
481 bool operator()(const StakeContenderId &contenderId) const;
482 bool operator()(const CTransactionRef &tx) const;
483 };
484 bool getLocalAcceptance(const AnyVoteItem &item) const {
485 return std::visit(GetLocalAcceptance(*this), item);
486 }
487
488 friend struct ::avalanche::AvalancheTest;
489};
490
491} // namespace avalanche
492
493#endif // BITCOIN_AVALANCHE_PROCESSOR_H
The block chain is a tree shaped structure starting with the genesis block at the root,...
Definition: blockindex.h:25
Definition: net.h:824
Inv(ventory) message data.
Definition: protocol.h:581
An encapsulated secp256k1 private key.
Definition: key.h:28
Information about a peer.
Definition: net.h:395
An encapsulated public key.
Definition: pubkey.h:31
RollingBloomFilter is a probabilistic "keep track of most recently inserted" set.
Definition: bloom.h:115
Simple class for background tasks that should be run periodically or once "after a while".
Definition: scheduler.h:41
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition: txmempool.h:214
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
Definition: validation.h:1158
Definition: config.h:19
Interface for message handling.
Definition: net.h:773
void sendResponse(CNode *pfrom, Response response) const
Definition: processor.cpp:543
const uint32_t staleVoteThreshold
Voting parameters.
Definition: processor.h:230
std::atomic< bool > quorumIsEstablished
Definition: processor.h:224
boost::multi_index_container< Query, boost::multi_index::indexed_by< boost::multi_index::hashed_unique< boost::multi_index::composite_key< Query, boost::multi_index::member< Query, NodeId, &Query::nodeid >, boost::multi_index::member< Query, uint64_t, &Query::round > > >, boost::multi_index::ordered_non_unique< boost::multi_index::tag< query_timeout >, boost::multi_index::member< Query, SteadyMilliseconds, &Query::timeout > > > > QuerySet
Definition: processor.h:207
AnyVoteItem getVoteItemFromInv(const CInv &inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Definition: processor.cpp:1356
Mutex cs_finalizedItems
Rolling bloom filter to track recently finalized inventory items of any type.
Definition: processor.h:451
bool sendHelloInternal(CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED(cs_delayedAvahelloNodeIds)
Definition: processor.cpp:708
int getConfidence(const AnyVoteItem &item) const
Definition: processor.cpp:477
bool addToReconcile(const AnyVoteItem &item) EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
Definition: processor.cpp:426
std::vector< CInv > getInvsForNextPoll(bool forPoll=true) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:1307
int64_t getAvaproofsNodeCounter() const
Definition: processor.h:344
RWCollection< QuerySet > queries
Definition: processor.h:209
bool hasFinalizedTip() const EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizationTip)
Whether there is a finalized tip.
Definition: processor.h:334
bool ProcessMessages(const ::Config &config, CNode *pnode, std::atomic< bool > &interrupt) override
Definition: processor.h:377
bool setContenderStatusForLocalWinners(const CBlockIndex *pindex, std::vector< StakeContenderId > &pollableContenders) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Helper to set the vote status for local winners in the contender cache.
Definition: processor.cpp:1126
void transactionAddedToMempool(const CTransactionRef &tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
Definition: processor.cpp:1194
const CBlockIndex *finalizationTip GUARDED_BY(cs_finalizationTip)
Definition: processor.h:238
bool sendHello(CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED(!cs_delayedAvahelloNodeIds)
Send a avahello message.
Definition: processor.cpp:743
bool isRecentlyFinalized(const uint256 &itemId) const EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
Definition: processor.cpp:501
void setRecentlyFinalized(const uint256 &itemId) EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
Definition: processor.cpp:505
bool startEventLoop(CScheduler &scheduler)
Definition: processor.cpp:775
bool isQuorumEstablished() LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:805
std::atomic< uint64_t > round
Keep track of peers and queries sent.
Definition: processor.h:173
static std::unique_ptr< Processor > MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain, CConnman *connman, ChainstateManager &chainman, CTxMemPool *mempoolIn, CScheduler &scheduler, bilingual_str &error)
Definition: processor.cpp:222
EventLoop eventLoop
Event loop machinery.
Definition: processor.h:217
CTxMemPool * mempool
Definition: processor.h:163
int64_t minAvaproofsNodeCount
Definition: processor.h:226
const bool m_preConsensus
Definition: processor.h:268
bool isPolled(const AnyVoteItem &item) const
Definition: processor.cpp:491
Mutex cs_delayedAvahelloNodeIds
Definition: processor.h:240
bool setStakingRewardWinners(const CBlockIndex *pprev, const std::vector< CScript > &payouts) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards
Definition: processor.cpp:1003
void runEventLoop() EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:1200
bool isAvalancheServiceAvailable()
Definition: processor.h:331
Mutex cs_invalidatedBlocks
We don't need many blocks but a low false positive rate.
Definition: processor.h:438
void updatedBlockTip() EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:1138
RWCollection< VoteMap > voteRecords
Items to run avalanche on.
Definition: processor.h:168
std::unique_ptr< interfaces::Handler > chainNotificationsHandler
Definition: processor.h:235
uint32_t minQuorumScore
Quorum management.
Definition: processor.h:222
void FinalizeNode(const ::Config &config, const CNode &node) override LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Handle removal of a node.
Definition: processor.cpp:1039
bool getStakingRewardWinners(const BlockHash &prevBlockHash, std::vector< std::pair< ProofId, CScript > > &winners) const EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
Definition: processor.cpp:974
std::atomic< bool > m_canShareLocalProof
Definition: processor.h:225
void cleanupStakingRewards(const int minHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards
Definition: processor.cpp:950
bool isAccepted(const AnyVoteItem &item) const
Definition: processor.cpp:463
ProofRef getLocalProof() const
Definition: processor.cpp:765
void acceptStakeContender(const StakeContenderId &contenderId) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Definition: processor.cpp:1070
void InitializeNode(const ::Config &config, CNode &pnode, ServiceFlags our_services) override
Definition: processor.h:375
bool reconcileOrFinalize(const ProofRef &proof) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Wrapper around the addToReconcile for proofs that adds back the finalization flag to the peer if it i...
Definition: processor.cpp:444
int getStakeContenderStatus(const StakeContenderId &contenderId) const EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Track votes on stake contenders.
Definition: processor.cpp:1047
const uint32_t staleVoteFactor
Definition: processor.h:231
void promoteAndPollStakeContenders(const CBlockIndex *pprev) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards
Promote stake contender cache entries to a given block and then poll.
Definition: processor.cpp:1102
void sendDelayedAvahello() EXCLUSIVE_LOCKS_REQUIRED(!cs_delayedAvahelloNodeIds)
Definition: processor.cpp:748
void finalizeStakeContender(const StakeContenderId &contenderId) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:1075
std::unique_ptr< PeerData > peerData
Definition: processor.h:213
bool eraseStakingRewardWinner(const BlockHash &prevBlockHash) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
Definition: processor.cpp:945
const bool m_stakingPreConsensus
Definition: processor.h:269
CConnman * connman
Definition: processor.h:161
bool isWorthPolling(const AnyVoteItem &item) const EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
Definition: processor.cpp:1449
CPubKey getSessionPubKey() const
Definition: processor.cpp:704
auto withPeerManager(Callable &&func) const EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Definition: processor.h:307
std::unique_ptr< PeerManager > peerManager GUARDED_BY(cs_peerManager)
Processor(Config avaconfig, interfaces::Chain &chain, CConnman *connmanIn, ChainstateManager &chainman, CTxMemPool *mempoolIn, CScheduler &scheduler, std::unique_ptr< PeerData > peerDataIn, CKey sessionKeyIn, uint32_t minQuorumTotalScoreIn, double minQuorumConnectedScoreRatioIn, int64_t minAvaproofsNodeCountIn, uint32_t staleVoteThresholdIn, uint32_t staleVoteFactorIn, Amount stakeUtxoDustThresholdIn, bool preConsensus, bool stakingPreConsensus)
Definition: processor.cpp:145
ChainstateManager & chainman
Definition: processor.h:162
std::atomic< int64_t > avaproofsNodeCounter
Definition: processor.h:227
bool SendMessages(const ::Config &config, CNode *pnode) override
Definition: processor.h:381
bool computeStakingReward(const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:905
ProofRegistrationState getLocalProofRegistrationState() const
Definition: processor.cpp:769
bool registerVotes(NodeId nodeid, const Response &response, std::vector< VoteItemUpdate > &updates, bool &disconnect, std::string &error) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Definition: processor.cpp:550
CRollingBloomFilter finalizedItems GUARDED_BY(cs_finalizedItems)
Definition: processor.h:452
void clearTimedoutRequests() EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Definition: processor.cpp:1268
std::unordered_map< BlockHash, StakingReward, SaltedUint256Hasher > stakingRewards GUARDED_BY(cs_stakingRewards)
Mutex cs_peerManager
Keep track of the peers and associated infos.
Definition: processor.h:178
bool getLocalAcceptance(const AnyVoteItem &item) const
Definition: processor.h:484
void rejectStakeContender(const StakeContenderId &contenderId) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Definition: processor.cpp:1097
std::unordered_set< NodeId > delayedAvahelloNodeIds GUARDED_BY(cs_delayedAvahelloNodeIds)
A list of the nodes that did not get our proof announced via avahello yet because we had no inbound c...
void avaproofsSent(NodeId nodeid) LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Definition: processor.cpp:784
double minQuorumConnectedScoreRatio
Definition: processor.h:223
void clearFinalizedItems() EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
Definition: processor.cpp:509
const AnyVoteItem & getVoteItem() const
Definition: processor.h:106
VoteItemUpdate(AnyVoteItem itemIn, VoteStatus statusIn)
Definition: processor.h:102
const VoteStatus & getStatus() const
Definition: processor.h:105
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
Definition: chain.h:136
256-bit opaque blob.
Definition: uint256.h:129
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition: cs_main.cpp:7
int64_t NodeId
Definition: eviction.h:16
bool error(const char *fmt, const Args &...args)
Definition: logging.h:263
std::variant< const ProofRef, const CBlockIndex *, const StakeContenderId, const CTransactionRef > AnyVoteItem
Definition: processor.h:95
std::map< AnyVoteItem, VoteRecord, VoteMapComparator > VoteMap
Definition: processor.h:149
RCUPtr< const Proof > ProofRef
Definition: proof.h:186
Definition: init.h:31
Implement std::hash so RCUPtr can be used as a key for maps or sets.
Definition: rcu.h:259
std::shared_ptr< const CTransaction > CTransactionRef
Definition: transaction.h:315
Response response
Definition: processor.cpp:520
static constexpr size_t AVALANCHE_CONTENDER_MAX_POLLABLE
Maximum number of stake contenders to poll for, leaving room for polling blocks and proofs in the sam...
Definition: processor.h:60
static constexpr std::chrono::milliseconds AVALANCHE_DEFAULT_QUERY_TIMEOUT
How long before we consider that a query timed out.
Definition: processor.h:65
static constexpr size_t AVALANCHE_MAX_ELEMENT_POLL
Maximum item that can be polled at once.
Definition: processor.h:54
static constexpr uint32_t AVALANCHE_FINALIZED_ITEMS_FILTER_NUM_ELEMENTS
The size of the finalized items filter.
Definition: processor.h:76
ServiceFlags
nServices flags.
Definition: protocol.h:335
Definition: amount.h:19
A BlockHash is a unqiue identifier for a block.
Definition: blockhash.h:13
bool operator()(const CBlockIndex *pindex) const LOCKS_EXCLUDED(cs_main)
Definition: processor.cpp:1454
GetLocalAcceptance(const Processor &_processor)
Definition: processor.h:474
IsWorthPolling(const Processor &_processor)
Definition: processor.h:458
bool operator()(const CBlockIndex *pindex) const LOCKS_EXCLUDED(cs_main)
Definition: processor.cpp:1387
SteadyMilliseconds timeout
Definition: processor.h:184
std::vector< CInv > invs
We declare this as mutable so it can be modified in the multi_index.
Definition: processor.h:192
std::vector< std::pair< ProofId, CScript > > winners
Definition: processor.h:251
Compare proofs by score, then by id in case of equality.
StakeContenderIds are unique for each block to ensure that the peer polling for their acceptance has ...
bool operator()(const AnyVoteItem &lhs, const AnyVoteItem &rhs) const
Definition: processor.h:110
Bilingual messages:
Definition: translation.h:17
#define LOCK(cs)
Definition: sync.h:306
#define EXCLUSIVE_LOCKS_REQUIRED(...)
Definition: threadsafety.h:56
#define LOCKS_EXCLUDED(...)
Definition: threadsafety.h:55
std::chrono::time_point< std::chrono::steady_clock, std::chrono::milliseconds > SteadyMilliseconds
Definition: time.h:31
assert(!tx.IsCoinBase())
static constexpr int AVALANCHE_MAX_INFLIGHT_POLL
How many inflight requests can exist for one item.
Definition: voterecord.h:40