45 uint256 hash = pindex->GetBlockHash();
60 if (!proof.
verify(stakeUtxoDustThreshold, proof_state)) {
63 error =
_(
"The avalanche proof has no stake.");
66 error =
_(
"The avalanche proof stake is too low.");
69 error =
_(
"The avalanche proof has duplicated stake.");
72 error =
_(
"The avalanche proof has invalid stake signatures.");
76 _(
"The avalanche proof has too many utxos (max: %u)."),
80 error =
_(
"The avalanche proof is invalid.");
94 if (!dg.
verify(dg_state, auth)) {
97 error =
_(
"The avalanche delegation has invalid signatures.");
101 "The avalanche delegation has too many delegation levels.");
104 error =
_(
"The avalanche delegation is invalid.");
109 if (auth != expectedPubKey) {
111 "The avalanche delegation does not match the expected public key.");
136 uint64_t mempool_sequence)
override {
144 std::unique_ptr<PeerData> peerDataIn,
CKey sessionKeyIn,
145 uint32_t minQuorumTotalScoreIn,
146 double minQuorumConnectedScoreRatioIn,
147 int64_t minAvaproofsNodeCountIn,
148 uint32_t staleVoteThresholdIn, uint32_t staleVoteFactorIn,
149 Amount stakeUtxoDustThreshold,
bool preConsensus)
150 : avaconfig(
std::move(avaconfigIn)), connman(connmanIn),
151 chainman(chainmanIn), mempool(mempoolIn), round(0),
153 stakeUtxoDustThreshold, chainman,
154 peerDataIn ? peerDataIn->proof :
ProofRef())),
155 peerData(
std::move(peerDataIn)), sessionKey(
std::move(sessionKeyIn)),
156 minQuorumScore(minQuorumTotalScoreIn),
157 minQuorumConnectedScoreRatio(minQuorumConnectedScoreRatioIn),
158 minAvaproofsNodeCount(minAvaproofsNodeCountIn),
159 staleVoteThreshold(staleVoteThresholdIn),
160 staleVoteFactor(staleVoteFactorIn), m_preConsensus(preConsensus) {
167 std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
169 peerManager->cleanupDanglingProofs(registeredProofs));
170 for (
const auto &proof : registeredProofs) {
172 "Promoting previously dangling proof %s\n",
173 proof->getId().ToString());
184 std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
189 dumpPath, registeredProofs));
194 for (
const auto &proof : registeredProofs) {
215 std::unique_ptr<Processor>
225 if (argsman.
IsArgSet(
"-avaproofstakeutxodustthreshold") &&
227 stakeUtxoDustThreshold)) {
228 error =
_(
"The avalanche stake utxo dust threshold amount is invalid.");
232 if (argsman.
IsArgSet(
"-avasessionkey")) {
235 error =
_(
"The avalanche session key is invalid.");
243 if (argsman.
IsArgSet(
"-avaproof")) {
244 if (!argsman.
IsArgSet(
"-avamasterkey")) {
246 "The avalanche master key is missing for the avalanche proof.");
252 error =
_(
"The avalanche master key is invalid.");
262 peerData = std::make_unique<PeerData>();
269 std::unique_ptr<DelegationBuilder> dgb;
272 if (argsman.
IsArgSet(
"-avadelegation")) {
281 error =
_(
"The delegation does not match the proof.");
287 "The master key does not match the delegation public key.");
291 dgb = std::make_unique<DelegationBuilder>(dg);
293 if (masterPubKey !=
peerData->proof->getMaster()) {
295 _(
"The master key does not match the proof public key.");
299 dgb = std::make_unique<DelegationBuilder>(*
peerData->proof);
304 if (sessionPubKey != masterPubKey) {
305 if (!dgb->addLevel(masterKey, sessionPubKey)) {
306 error =
_(
"Failed to generate a delegation for this session.");
310 peerData->delegation = dgb->build();
318 const auto queryTimeoutDuration =
319 std::chrono::milliseconds(argsman.
GetIntArg(
324 if (argsman.
IsArgSet(
"-avaminquorumstake") &&
326 error =
_(
"The avalanche min quorum stake amount is invalid.");
331 error =
_(
"The avalanche min quorum stake amount is out of range.");
335 double minQuorumConnectedStakeRatio =
337 if (argsman.
IsArgSet(
"-avaminquorumconnectedstakeratio") &&
339 &minQuorumConnectedStakeRatio)) {
340 error =
_(
"The avalanche min quorum connected stake ratio is invalid.");
344 if (minQuorumConnectedStakeRatio < 0 || minQuorumConnectedStakeRatio > 1) {
346 "The avalanche min quorum connected stake ratio is out of range.");
351 argsman.
GetIntArg(
"-avaminavaproofsnodecount",
354 error =
_(
"The minimum number of node that sent avaproofs message "
355 "should be non-negative");
364 "greater than or equal to %d"),
370 "than or equal to %d"),
371 std::numeric_limits<uint32_t>::max());
378 error =
_(
"The avalanche stale vote factor must be greater than 0");
382 error =
strprintf(
_(
"The avalanche stale vote factor must be less than "
384 std::numeric_limits<uint32_t>::max());
391 return std::unique_ptr<Processor>(
new Processor(
396 stakeUtxoDustThreshold,
402 return item.valueless_by_exception() ||
403 std::visit([](
const auto &item) {
return item ==
nullptr; }, item);
420 ->insert(std::make_pair(item,
VoteRecord(accepted)))
432 if (peerManager->forPeer(proof->getId(), [&](
const Peer &peer) {
433 peerid = peer.peerid;
436 return peerManager->setFinalized(peerid);
449 auto it = r->find(item);
454 return it->second.isAccepted();
463 auto it = r->find(item);
468 return it->second.getConfidence();
477 finalizedItems.reset();
490 TCPResponse(Response responseIn,
const CKey &key)
494 const uint256 hash = hasher.GetHash();
517 std::vector<VoteItemUpdate> &updates,
518 int &banscore, std::string &
error) {
526 peerManager->updateNextRequestTime(
527 nodeid, Now<SteadyMilliseconds>() +
528 std::chrono::milliseconds(
response.getCooldown()));
531 std::vector<CInv> invs;
539 auto it = w->find(std::make_tuple(nodeid,
response.getRound()));
542 error =
"unexpected-ava-response";
546 invs = std::move(it->invs);
551 const std::vector<Vote> &votes =
response.GetVotes();
552 size_t size = invs.size();
553 if (votes.size() != size) {
555 error =
"invalid-ava-response-size";
559 for (
size_t i = 0; i < size; i++) {
560 if (invs[i].hash != votes[i].GetHash()) {
562 error =
"invalid-ava-response-content";
567 std::map<AnyVoteItem, Vote, VoteMapComparator> responseItems;
571 for (
size_t i = 0; i < size; i++) {
584 responseItems.insert(std::make_pair(std::move(item), votes[i]));
590 for (
const auto &p : responseItems) {
592 const Vote &v = p.second;
594 auto it = voteRecordsWriteView->find(item);
595 if (it == voteRecordsWriteView.end()) {
600 auto &vr = it->second;
601 if (!vr.registerVote(nodeid, v.
GetError())) {
607 voteRecordsWriteView->erase(it);
613 if (!vr.hasFinalized()) {
616 updates.emplace_back(std::move(item), vr.isAccepted()
624 updates.emplace_back(std::move(item), vr.isAccepted()
627 voteRecordsWriteView->erase(it);
632 for (
const auto &update : updates) {
638 const auto &item = update.getVoteItem();
647 if (!std::holds_alternative<const CBlockIndex *>(item)) {
663 const CBlockIndex *pindex = std::get<const CBlockIndex *>(item);
665 if (finalizationTip &&
666 finalizationTip->GetAncestor(pindex->
nHeight) == pindex) {
670 finalizationTip = pindex;
686 if (!delayedAvahelloNodeIds.emplace(pfrom->
GetId()).second) {
696 hasher << delegation.
getId();
723 auto it = delayedAvahelloNodeIds.begin();
724 while (it != delayedAvahelloNodeIds.end()) {
730 it = delayedAvahelloNodeIds.erase(it);
759 if (
chainman.ActiveChainstate().IsInitialBlockDownload()) {
768 if (peerManager->latchAvaproofsSent(nodeid)) {
782 if (peerManager->getNodeCount() < 8) {
804 if (
chainman.ActiveChainstate().IsInitialBlockDownload()) {
815 uint32_t totalPeersScore;
816 uint32_t connectedPeersScore;
819 totalPeersScore = peerManager->getTotalPeersScore();
820 connectedPeersScore = peerManager->getConnectedPeersScore();
825 peerManager->forPeer(localProof->getId(), [](
const Peer &peer) {
826 return peer.node_count == 0;
828 connectedPeersScore += localProof->getScore();
838 uint32_t minConnectedScore =
840 if (connectedPeersScore < minConnectedScore) {
892 pindex, _stakingRewards.
winners))) {
894 return stakingRewards
895 .emplace(pindex->
GetBlockHash(), std::move(_stakingRewards))
904 return stakingRewards.erase(prevBlockHash) > 0;
910 for (
auto it = stakingRewards.begin(); it != stakingRewards.end();) {
911 if (it->second.blockheight < minHeight) {
912 it = stakingRewards.erase(it);
921 std::vector<std::pair<ProofId, CScript>> &winners)
const {
923 auto it = stakingRewards.find(prevBlockHash);
924 if (it == stakingRewards.end()) {
928 winners = it->second.winners;
933 std::vector<CScript> &payouts)
const {
934 std::vector<std::pair<ProofId, CScript>> winners;
940 payouts.reserve(winners.size());
941 for (
auto &winner : winners) {
942 payouts.push_back(std::move(winner.second));
949 const std::vector<CScript> &payouts) {
955 stakingReward.
winners.reserve(payouts.size());
956 for (
const CScript &payout : payouts) {
961 return stakingRewards.insert_or_assign(pprev->
GetBlockHash(), stakingReward)
975 auto registerProofs = [&]() {
978 auto registeredProofs = peerManager->updatedBlockTip();
982 if (peerManager->registerProof(
peerData->proof, localProofState)) {
983 registeredProofs.insert(
peerData->proof);
994 if (peerManager->isImmature(localProofId)) {
998 if (peerManager->isInConflictingPool(localProofId)) {
1001 "conflicting-utxos");
1003 if (peerManager->isBoundToPeer(localProofId)) {
1009 peerData->proofState = std::move(localProofState));
1012 return registeredProofs;
1015 auto registeredProofs = registerProofs();
1016 for (
const auto &proof : registeredProofs) {
1059 uint64_t current_round =
round++;
1063 auto timeout = Now<SteadyMilliseconds>() +
1067 {pnode->
GetId(), current_round, timeout, invs});
1069 peerManager->updateNextRequestTime(pnode->
GetId(), timeout);
1078 Poll(current_round, std::move(invs))));
1088 peerManager->removeNode(nodeid);
1091 nodeid = peerManager->selectNode();
1096 auto now = Now<SteadyMilliseconds>();
1097 std::map<CInv, uint8_t> timedout_items{};
1103 while (it != w->get<
query_timeout>().end() && it->timeout < now) {
1104 for (
const auto &i : it->invs) {
1105 timedout_items[i]++;
1112 if (timedout_items.empty()) {
1118 for (
const auto &p : timedout_items) {
1125 auto it = voteRecordsWriteView->find(item);
1126 if (it == voteRecordsWriteView.end()) {
1130 it->second.clearInflightRequest(p.second);
1135 std::vector<CInv> invs;
1140 for (
auto it = w->begin(); it != w->end();) {
1160 for (
const auto &[item, voteRecord] : r) {
1167 const bool shouldPoll =
1168 forPoll ? voteRecord.registerPoll() : voteRecord.shouldPoll();
1174 invs.emplace_back(std::visit(buildInvFromVoteItem, item));
1203 if (pindex->nStatus.isInvalid()) {
1211 pindex->
nHeight) == pindex)) {
1218 return processor.invalidatedBlocks.contains(
1232 const ProofId &proofid = proof->getId();
1234 LOCK(processor.cs_peerManager);
1237 return processor.peerManager->isBoundToPeer(proofid) ||
1238 processor.peerManager->isInConflictingPool(proofid);
1242 if (!processor.mempool) {
1250 return processor.mempool->exists(tx->GetId()));
1263 return processor.chainman.ActiveChain().Contains(pindex));
1270 processor.cs_peerManager,
1271 return processor.peerManager->isBoundToPeer(proof->getId()));
1276 if (!processor.mempool) {
1283 return processor.mempool->exists(tx->GetId()));
bool MoneyRange(const Amount nValue)
static constexpr bool DEFAULT_PERSIST_AVAPEERS
Default for -persistavapeers.
static constexpr double AVALANCHE_DEFAULT_MIN_QUORUM_CONNECTED_STAKE_RATIO
Default minimum percentage of stake-weighted peers we must have a node for to constitute a usable quo...
static constexpr double AVALANCHE_DEFAULT_MIN_AVAPROOFS_NODE_COUNT
Default minimum number of nodes that sent us an avaproofs message before we can consider our quorum s...
static constexpr bool DEFAULT_AVALANCHE_PRECONSENSUS
Default for -avalanchepreconsensus.
static constexpr Amount AVALANCHE_DEFAULT_MIN_QUORUM_STAKE
Default minimum cumulative stake of all known peers that constitutes a usable quorum.
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
const fs::path & GetDataDirNet() const
Get data directory path with appended network identifier.
int64_t GetIntArg(const std::string &strArg, int64_t nDefault) const
Return integer argument or default value.
std::string GetArg(const std::string &strArg, const std::string &strDefault) const
Return string argument or default value.
bool GetBoolArg(const std::string &strArg, bool fDefault) const
Return boolean argument or default value.
The block chain is a tree shaped structure starting with the genesis block at the root,...
BlockHash GetBlockHash() const
int nHeight
height of the entry in the chain. The genesis block has height 0
size_t GetNodeCount(NumConnections num) const
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg)
Inv(ventory) message data.
An encapsulated secp256k1 private key.
bool IsValid() const
Check whether this private key is valid.
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
CPubKey GetPubKey() const
Compute the public key from a private key.
bool SignSchnorr(const uint256 &hash, SchnorrSig &sig, uint32_t test_case=0) const
Create a Schnorr signature.
CSerializedNetMsg Make(int nFlags, std::string msg_type, Args &&...args) const
Information about a peer.
uint64_t GetLocalNonce() const
int GetCommonVersion() const
uint64_t nRemoteHostNonce
uint64_t nRemoteExtraEntropy
uint64_t GetLocalExtraEntropy() const
void invsPolled(uint32_t count)
The node was polled for count invs.
An encapsulated public key.
Simple class for background tasks that should be run periodically or once "after a while".
void scheduleEvery(Predicate p, std::chrono::milliseconds delta) EXCLUSIVE_LOCKS_REQUIRED(!newTaskMutex)
Repeat p until it return false.
Serialized script, used inside transaction inputs and outputs.
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
RecursiveMutex cs
This mutex needs to be locked when accessing mapTx or other members that are guarded by it.
CTransactionRef get(const TxId &txid) const
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
CBlockIndex * ActiveTip() const EXCLUSIVE_LOCKS_REQUIRED(GetMutex())
const Consensus::Params & GetConsensus() const
node::BlockManager m_blockman
A single BlockManager instance is shared across each constructed chainstate to avoid duplicating bloc...
A writer stream (for serialization) that computes a 256-bit hash.
static RCUPtr make(Args &&...args)
Construct a new object that is owned by the pointer.
ReadView getReadView() const
bool Invalid(Result result, const std::string &reject_reason="", const std::string &debug_message="")
ProofId getProofId() const
static bool FromHex(Delegation &dg, const std::string &dgHex, bilingual_str &errorOut)
bool verify(DelegationState &state, CPubKey &auth) const
const LimitedProofId & getLimitedProofId() const
const CPubKey & getDelegatedPubkey() const
const DelegationId & getId() const
void updatedBlockTip() override
NotificationsHandler(Processor *p)
void transactionAddedToMempool(const CTransactionRef &tx, uint64_t mempool_sequence) override
void sendResponse(CNode *pfrom, Response response) const
const uint32_t staleVoteThreshold
Voting parameters.
std::atomic< bool > quorumIsEstablished
AnyVoteItem getVoteItemFromInv(const CInv &inv) const EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Mutex cs_finalizedItems
Rolling bloom filter to track recently finalized inventory items of any type.
bool sendHelloInternal(CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED(cs_delayedAvahelloNodeIds)
int getConfidence(const AnyVoteItem &item) const
bool addToReconcile(const AnyVoteItem &item) EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
std::vector< CInv > getInvsForNextPoll(bool forPoll=true) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
RWCollection< QuerySet > queries
bool registerVotes(NodeId nodeid, const Response &response, std::vector< VoteItemUpdate > &updates, int &banscore, std::string &error) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
void transactionAddedToMempool(const CTransactionRef &tx) EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
bool sendHello(CNode *pfrom) EXCLUSIVE_LOCKS_REQUIRED(!cs_delayedAvahelloNodeIds)
Send a avahello message.
bool isRecentlyFinalized(const uint256 &itemId) const EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
bool startEventLoop(CScheduler &scheduler)
bool isQuorumEstablished() LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
bool getStakingRewardWinners(const BlockHash &prevBlockHash, std::vector< std::pair< ProofId, CScript >> &winners) const EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
std::atomic< uint64_t > round
Keep track of peers and queries sent.
bool canShareLocalProof()
static std::unique_ptr< Processor > MakeProcessor(const ArgsManager &argsman, interfaces::Chain &chain, CConnman *connman, ChainstateManager &chainman, CTxMemPool *mempoolIn, CScheduler &scheduler, bilingual_str &error)
EventLoop eventLoop
Event loop machinery.
int64_t minAvaproofsNodeCount
const bool m_preConsensus
Mutex cs_delayedAvahelloNodeIds
void runEventLoop() EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Mutex cs_invalidatedBlocks
We don't need many blocks but a low false positive rate.
void updatedBlockTip() EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
RWCollection< VoteMap > voteRecords
Items to run avalanche on.
std::unique_ptr< interfaces::Handler > chainNotificationsHandler
uint32_t minQuorumScore
Quorum management.
void FinalizeNode(const ::Config &config, const CNode &node) override LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Handle removal of a node.
std::atomic< bool > m_canShareLocalProof
bool isAccepted(const AnyVoteItem &item) const
ProofRef getLocalProof() const
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...
const uint32_t staleVoteFactor
void sendDelayedAvahello() EXCLUSIVE_LOCKS_REQUIRED(!cs_delayedAvahelloNodeIds)
std::unique_ptr< PeerData > peerData
bool eraseStakingRewardWinner(const BlockHash &prevBlockHash) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
bool isWorthPolling(const AnyVoteItem &item) const EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
CPubKey getSessionPubKey() const
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)
ChainstateManager & chainman
std::atomic< int64_t > avaproofsNodeCounter
bool computeStakingReward(const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
ProofRegistrationState getLocalProofRegistrationState() const
bool setStakingRewardWinners(const CBlockIndex *pprev, const std::vector< CScript > &payouts) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
void cleanupStakingRewards(const int minHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
void clearTimedoutRequests() EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
Mutex cs_peerManager
Keep track of the peers and associated infos.
bool getLocalAcceptance(const AnyVoteItem &item) const
void avaproofsSent(NodeId nodeid) LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
double minQuorumConnectedScoreRatio
void clearFinalizedItems() EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
static bool FromHex(Proof &proof, const std::string &hexProof, bilingual_str &errorOut)
bool verify(const Amount &stakeUtxoDustThreshold, ProofValidationState &state) const
static uint32_t amountToScore(Amount amount)
uint32_t GetError() const
Path class wrapper to block calls to the fs::path(std::string) implicit constructor and the fs::path:...
Interface giving clients (wallet processes, maybe other analysis tools in the future) ability to acce...
virtual std::unique_ptr< Handler > handleNotifications(std::shared_ptr< Notifications > notifications)=0
Register handler for notifications.
CBlockIndex * LookupBlockIndex(const BlockHash &hash) EXCLUSIVE_LOCKS_REQUIRED(cs_main)
static const uint256 ZERO
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
std::array< uint8_t, CPubKey::SCHNORR_SIZE > SchnorrSig
a Schnorr signature
CKey DecodeSecret(const std::string &str)
bool error(const char *fmt, const Args &...args)
#define LogPrint(category,...)
bool ParseMoney(const std::string &money_string, Amount &nRet)
Parse an amount denoted in full coins.
const char * AVAHELLO
Contains a delegation and a signature.
const char * AVARESPONSE
Contains an avalanche::Response.
const char * AVAPOLL
Contains an avalanche::Poll.
static constexpr Amount PROOF_DUST_THRESHOLD
Minimum amount per utxo.
@ INVALID_STAKE_SIGNATURE
static bool VerifyDelegation(const Delegation &dg, const CPubKey &expectedPubKey, bilingual_str &error)
static bool isNull(const AnyVoteItem &item)
std::variant< const ProofRef, const CBlockIndex *, const CTransactionRef > AnyVoteItem
static const uint256 GetVoteItemId(const AnyVoteItem &item)
static bool VerifyProof(const Amount &stakeUtxoDustThreshold, const Proof &proof, bilingual_str &error)
RCUPtr< const Proof > ProofRef
static std::string PathToString(const path &path)
Convert path object to byte string.
Implement std::hash so RCUPtr can be used as a key for maps or sets.
static constexpr NodeId NO_NODE
Special NodeId that represent no node.
std::shared_ptr< const CTransaction > CTransactionRef
static const std::string AVAPEERS_FILE_NAME
static constexpr std::chrono::milliseconds AVALANCHE_TIME_STEP
Run the avalanche event loop every 10ms.
static constexpr std::chrono::milliseconds AVALANCHE_DEFAULT_QUERY_TIMEOUT
How long before we consider that a query timed out.
static constexpr size_t AVALANCHE_MAX_ELEMENT_POLL
Maximum item that can be polled at once.
static constexpr int AVALANCHE_MAX_PROOF_STAKES
How many UTXOs can be used for a single proof.
#define SERIALIZE_METHODS(cls, obj)
Implement the Serialize and Unserialize methods by delegating to a single templated static method tha...
bool IsStakingRewardsActivated(const Consensus::Params ¶ms, const CBlockIndex *pprev)
bool ParseDouble(const std::string &str, double *out)
Convert string to double with strict parse error feedback.
A BlockHash is a unqiue identifier for a block.
bool stopEventLoop() EXCLUSIVE_LOCKS_REQUIRED(!cs_running)
bool startEventLoop(CScheduler &scheduler, std::function< void()> runEventLoop, std::chrono::milliseconds delta) EXCLUSIVE_LOCKS_REQUIRED(!cs_running)
A TxId is the identifier of a transaction.
const std::chrono::milliseconds queryTimeoutDuration
bool operator()(const CBlockIndex *pindex) const LOCKS_EXCLUDED(cs_main)
const Processor & processor
bool operator()(const CBlockIndex *pindex) const LOCKS_EXCLUDED(cs_main)
ProofRegistrationState proofState GUARDED_BY(cs_proofState)
std::vector< std::pair< ProofId, CScript > > winners
#define AssertLockNotHeld(cs)
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
#define EXCLUSIVE_LOCKS_REQUIRED(...)
bilingual_str _(const char *psz)
Translation function.
static constexpr uint32_t AVALANCHE_VOTE_STALE_FACTOR
Scaling factor applied to confidence to determine staleness threshold.
static constexpr uint32_t AVALANCHE_VOTE_STALE_MIN_THRESHOLD
Lowest configurable staleness threshold (finalization score + necessary votes to increase confidence ...
static constexpr uint32_t AVALANCHE_VOTE_STALE_THRESHOLD
Number of votes before a record may be considered as stale.