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),
154 stakeUtxoDustThreshold, chainman,
155 peerDataIn ? peerDataIn->proof :
ProofRef())),
156 peerData(
std::move(peerDataIn)), sessionKey(
std::move(sessionKeyIn)),
157 minQuorumScore(minQuorumTotalScoreIn),
158 minQuorumConnectedScoreRatio(minQuorumConnectedScoreRatioIn),
159 minAvaproofsNodeCount(minAvaproofsNodeCountIn),
160 staleVoteThreshold(staleVoteThresholdIn),
161 staleVoteFactor(staleVoteFactorIn), m_preConsensus(preConsensus) {
168 std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
170 peerManager->cleanupDanglingProofs(registeredProofs));
171 for (
const auto &proof : registeredProofs) {
173 "Promoting previously dangling proof %s\n",
174 proof->getId().ToString());
185 std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
190 dumpPath, registeredProofs));
195 for (
const auto &proof : registeredProofs) {
216 std::unique_ptr<Processor>
226 if (argsman.
IsArgSet(
"-avaproofstakeutxodustthreshold") &&
228 stakeUtxoDustThreshold)) {
229 error =
_(
"The avalanche stake utxo dust threshold amount is invalid.");
233 if (argsman.
IsArgSet(
"-avasessionkey")) {
236 error =
_(
"The avalanche session key is invalid.");
244 if (argsman.
IsArgSet(
"-avaproof")) {
245 if (!argsman.
IsArgSet(
"-avamasterkey")) {
247 "The avalanche master key is missing for the avalanche proof.");
253 error =
_(
"The avalanche master key is invalid.");
263 peerData = std::make_unique<PeerData>();
270 std::unique_ptr<DelegationBuilder> dgb;
273 if (argsman.
IsArgSet(
"-avadelegation")) {
282 error =
_(
"The delegation does not match the proof.");
288 "The master key does not match the delegation public key.");
292 dgb = std::make_unique<DelegationBuilder>(dg);
294 if (masterPubKey !=
peerData->proof->getMaster()) {
296 _(
"The master key does not match the proof public key.");
300 dgb = std::make_unique<DelegationBuilder>(*
peerData->proof);
305 if (sessionPubKey != masterPubKey) {
306 if (!dgb->addLevel(masterKey, sessionPubKey)) {
307 error =
_(
"Failed to generate a delegation for this session.");
311 peerData->delegation = dgb->build();
319 const auto queryTimeoutDuration =
320 std::chrono::milliseconds(argsman.
GetIntArg(
325 if (argsman.
IsArgSet(
"-avaminquorumstake") &&
327 error =
_(
"The avalanche min quorum stake amount is invalid.");
332 error =
_(
"The avalanche min quorum stake amount is out of range.");
336 double minQuorumConnectedStakeRatio =
338 if (argsman.
IsArgSet(
"-avaminquorumconnectedstakeratio") &&
340 &minQuorumConnectedStakeRatio)) {
341 error =
_(
"The avalanche min quorum connected stake ratio is invalid.");
345 if (minQuorumConnectedStakeRatio < 0 || minQuorumConnectedStakeRatio > 1) {
347 "The avalanche min quorum connected stake ratio is out of range.");
352 argsman.
GetIntArg(
"-avaminavaproofsnodecount",
355 error =
_(
"The minimum number of node that sent avaproofs message "
356 "should be non-negative");
365 "greater than or equal to %d"),
371 "than or equal to %d"),
372 std::numeric_limits<uint32_t>::max());
379 error =
_(
"The avalanche stale vote factor must be greater than 0");
383 error =
strprintf(
_(
"The avalanche stale vote factor must be less than "
385 std::numeric_limits<uint32_t>::max());
392 return std::unique_ptr<Processor>(
new Processor(
397 stakeUtxoDustThreshold,
403 return item.valueless_by_exception() ||
404 std::visit([](
const auto &item) {
return item ==
nullptr; }, item);
421 ->insert(std::make_pair(item,
VoteRecord(accepted)))
433 if (peerManager->forPeer(proof->getId(), [&](
const Peer &peer) {
434 peerid = peer.peerid;
437 return peerManager->setFinalized(peerid);
450 auto it = r->find(item);
455 return it->second.isAccepted();
464 auto it = r->find(item);
469 return it->second.getConfidence();
478 finalizedItems.reset();
491 TCPResponse(Response responseIn,
const CKey &key)
495 const uint256 hash = hasher.GetHash();
518 std::vector<VoteItemUpdate> &updates,
519 int &banscore, std::string &
error) {
527 peerManager->updateNextRequestTime(
528 nodeid, Now<SteadyMilliseconds>() +
529 std::chrono::milliseconds(
response.getCooldown()));
532 std::vector<CInv> invs;
540 auto it = w->find(std::make_tuple(nodeid,
response.getRound()));
543 error =
"unexpected-ava-response";
547 invs = std::move(it->invs);
552 const std::vector<Vote> &votes =
response.GetVotes();
553 size_t size = invs.size();
554 if (votes.size() != size) {
556 error =
"invalid-ava-response-size";
560 for (
size_t i = 0; i < size; i++) {
561 if (invs[i].hash != votes[i].GetHash()) {
563 error =
"invalid-ava-response-content";
568 std::map<AnyVoteItem, Vote, VoteMapComparator> responseItems(
573 for (
size_t i = 0; i < size; i++) {
586 responseItems.insert(std::make_pair(std::move(item), votes[i]));
592 for (
const auto &p : responseItems) {
594 const Vote &v = p.second;
596 auto it = voteRecordsWriteView->find(item);
597 if (it == voteRecordsWriteView.end()) {
602 auto &vr = it->second;
603 if (!vr.registerVote(nodeid, v.
GetError())) {
609 voteRecordsWriteView->erase(it);
615 if (!vr.hasFinalized()) {
618 updates.emplace_back(std::move(item), vr.isAccepted()
626 updates.emplace_back(std::move(item), vr.isAccepted()
629 voteRecordsWriteView->erase(it);
634 for (
const auto &update : updates) {
640 const auto &item = update.getVoteItem();
649 if (!std::holds_alternative<const CBlockIndex *>(item)) {
665 const CBlockIndex *pindex = std::get<const CBlockIndex *>(item);
667 if (finalizationTip &&
668 finalizationTip->GetAncestor(pindex->
nHeight) == pindex) {
672 finalizationTip = pindex;
688 if (!delayedAvahelloNodeIds.emplace(pfrom->
GetId()).second) {
698 hasher << delegation.
getId();
725 auto it = delayedAvahelloNodeIds.begin();
726 while (it != delayedAvahelloNodeIds.end()) {
732 it = delayedAvahelloNodeIds.erase(it);
761 if (
chainman.ActiveChainstate().IsInitialBlockDownload()) {
770 if (peerManager->latchAvaproofsSent(nodeid)) {
784 if (peerManager->getNodeCount() < 8) {
806 if (
chainman.ActiveChainstate().IsInitialBlockDownload()) {
817 uint32_t totalPeersScore;
818 uint32_t connectedPeersScore;
821 totalPeersScore = peerManager->getTotalPeersScore();
822 connectedPeersScore = peerManager->getConnectedPeersScore();
827 peerManager->forPeer(localProof->getId(), [](
const Peer &peer) {
828 return peer.node_count == 0;
830 connectedPeersScore += localProof->getScore();
840 uint32_t minConnectedScore =
842 if (connectedPeersScore < minConnectedScore) {
894 pindex, _stakingRewards.
winners))) {
896 return stakingRewards
897 .emplace(pindex->
GetBlockHash(), std::move(_stakingRewards))
906 return stakingRewards.erase(prevBlockHash) > 0;
912 for (
auto it = stakingRewards.begin(); it != stakingRewards.end();) {
913 if (it->second.blockheight < minHeight) {
914 it = stakingRewards.erase(it);
923 std::vector<std::pair<ProofId, CScript>> &winners)
const {
925 auto it = stakingRewards.find(prevBlockHash);
926 if (it == stakingRewards.end()) {
930 winners = it->second.winners;
935 std::vector<CScript> &payouts)
const {
936 std::vector<std::pair<ProofId, CScript>> winners;
942 payouts.reserve(winners.size());
943 for (
auto &winner : winners) {
944 payouts.push_back(std::move(winner.second));
951 const std::vector<CScript> &payouts) {
957 stakingReward.
winners.reserve(payouts.size());
958 for (
const CScript &payout : payouts) {
963 return stakingRewards.insert_or_assign(pprev->
GetBlockHash(), stakingReward)
977 auto registerProofs = [&]() {
980 auto registeredProofs = peerManager->updatedBlockTip();
984 if (peerManager->registerProof(
peerData->proof, localProofState)) {
985 registeredProofs.insert(
peerData->proof);
996 if (peerManager->isImmature(localProofId)) {
1000 if (peerManager->isInConflictingPool(localProofId)) {
1003 "conflicting-utxos");
1005 if (peerManager->isBoundToPeer(localProofId)) {
1011 peerData->proofState = std::move(localProofState));
1014 return registeredProofs;
1017 auto registeredProofs = registerProofs();
1018 for (
const auto &proof : registeredProofs) {
1061 uint64_t current_round =
round++;
1065 auto timeout = Now<SteadyMilliseconds>() +
1069 {pnode->
GetId(), current_round, timeout, invs});
1071 peerManager->updateNextRequestTime(pnode->
GetId(), timeout);
1080 Poll(current_round, std::move(invs))));
1090 peerManager->removeNode(nodeid);
1093 nodeid = peerManager->selectNode();
1098 auto now = Now<SteadyMilliseconds>();
1099 std::map<CInv, uint8_t> timedout_items{};
1105 while (it != w->get<
query_timeout>().end() && it->timeout < now) {
1106 for (
const auto &i : it->invs) {
1107 timedout_items[i]++;
1114 if (timedout_items.empty()) {
1120 for (
const auto &p : timedout_items) {
1127 auto it = voteRecordsWriteView->find(item);
1128 if (it == voteRecordsWriteView.end()) {
1132 it->second.clearInflightRequest(p.second);
1137 std::vector<CInv> invs;
1142 for (
auto it = w->begin(); it != w->end();) {
1162 for (
const auto &[item, voteRecord] : r) {
1169 const bool shouldPoll =
1170 forPoll ? voteRecord.registerPoll() : voteRecord.shouldPoll();
1176 invs.emplace_back(std::visit(buildInvFromVoteItem, item));
1205 if (pindex->nStatus.isInvalid()) {
1213 pindex->
nHeight) == pindex)) {
1220 return processor.invalidatedBlocks.contains(
1234 const ProofId &proofid = proof->getId();
1236 LOCK(processor.cs_peerManager);
1239 return processor.peerManager->isBoundToPeer(proofid) ||
1240 processor.peerManager->isInConflictingPool(proofid);
1244 if (!processor.mempool) {
1252 return processor.mempool->exists(tx->GetId()));
1265 return processor.chainman.ActiveChain().Contains(pindex));
1272 processor.cs_peerManager,
1273 return processor.peerManager->isBoundToPeer(proof->getId()));
1278 if (!processor.mempool) {
1285 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.
std::map< AnyVoteItem, VoteRecord, VoteMapComparator > VoteMap
@ 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.