46 uint256 hash = pindex->GetBlockHash();
64 if (!proof.
verify(stakeUtxoDustThreshold, proof_state)) {
67 error =
_(
"The avalanche proof has no stake.");
70 error =
_(
"The avalanche proof stake is too low.");
73 error =
_(
"The avalanche proof has duplicated stake.");
76 error =
_(
"The avalanche proof has invalid stake signatures.");
80 _(
"The avalanche proof has too many utxos (max: %u)."),
84 error =
_(
"The avalanche proof is invalid.");
98 if (!dg.
verify(dg_state, auth)) {
101 error =
_(
"The avalanche delegation has invalid signatures.");
105 "The avalanche delegation has too many delegation levels.");
108 error =
_(
"The avalanche delegation is invalid.");
113 if (auth != expectedPubKey) {
115 "The avalanche delegation does not match the expected public key.");
140 uint64_t mempool_sequence)
override {
148 std::unique_ptr<PeerData> peerDataIn,
CKey sessionKeyIn,
149 uint32_t minQuorumTotalScoreIn,
150 double minQuorumConnectedScoreRatioIn,
151 int64_t minAvaproofsNodeCountIn,
152 uint32_t staleVoteThresholdIn, uint32_t staleVoteFactorIn,
153 Amount stakeUtxoDustThreshold,
bool preConsensus,
154 bool stakingPreConsensus)
155 : avaconfig(
std::move(avaconfigIn)), connman(connmanIn),
156 chainman(chainmanIn), mempool(mempoolIn), round(0),
158 stakeUtxoDustThreshold, chainman, stakingPreConsensus,
159 peerDataIn ? peerDataIn->proof :
ProofRef())),
160 peerData(
std::move(peerDataIn)), sessionKey(
std::move(sessionKeyIn)),
161 minQuorumScore(minQuorumTotalScoreIn),
162 minQuorumConnectedScoreRatio(minQuorumConnectedScoreRatioIn),
163 minAvaproofsNodeCount(minAvaproofsNodeCountIn),
164 staleVoteThreshold(staleVoteThresholdIn),
165 staleVoteFactor(staleVoteFactorIn), m_preConsensus(preConsensus),
166 m_stakingPreConsensus(stakingPreConsensus) {
173 std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
175 peerManager->cleanupDanglingProofs(registeredProofs));
176 for (
const auto &proof : registeredProofs) {
178 "Promoting previously dangling proof %s\n",
179 proof->getId().ToString());
190 std::unordered_set<ProofRef, SaltedProofHasher> registeredProofs;
195 dumpPath, registeredProofs));
200 for (
const auto &proof : registeredProofs) {
221std::unique_ptr<Processor>
231 if (argsman.
IsArgSet(
"-avaproofstakeutxodustthreshold") &&
233 stakeUtxoDustThreshold)) {
234 error =
_(
"The avalanche stake utxo dust threshold amount is invalid.");
238 if (argsman.
IsArgSet(
"-avasessionkey")) {
241 error =
_(
"The avalanche session key is invalid.");
249 if (argsman.
IsArgSet(
"-avaproof")) {
250 if (!argsman.
IsArgSet(
"-avamasterkey")) {
252 "The avalanche master key is missing for the avalanche proof.");
258 error =
_(
"The avalanche master key is invalid.");
268 peerData = std::make_unique<PeerData>();
275 std::unique_ptr<DelegationBuilder> dgb;
278 if (argsman.
IsArgSet(
"-avadelegation")) {
287 error =
_(
"The delegation does not match the proof.");
293 "The master key does not match the delegation public key.");
297 dgb = std::make_unique<DelegationBuilder>(dg);
299 if (masterPubKey !=
peerData->proof->getMaster()) {
301 _(
"The master key does not match the proof public key.");
305 dgb = std::make_unique<DelegationBuilder>(*
peerData->proof);
310 if (sessionPubKey != masterPubKey) {
311 if (!dgb->addLevel(masterKey, sessionPubKey)) {
312 error =
_(
"Failed to generate a delegation for this session.");
316 peerData->delegation = dgb->build();
324 const auto queryTimeoutDuration =
325 std::chrono::milliseconds(argsman.
GetIntArg(
330 if (argsman.
IsArgSet(
"-avaminquorumstake") &&
332 error =
_(
"The avalanche min quorum stake amount is invalid.");
337 error =
_(
"The avalanche min quorum stake amount is out of range.");
341 double minQuorumConnectedStakeRatio =
343 if (argsman.
IsArgSet(
"-avaminquorumconnectedstakeratio")) {
345 int64_t megaMinRatio;
347 argsman.
GetArg(
"-avaminquorumconnectedstakeratio",
""), 6,
350 _(
"The avalanche min quorum connected stake ratio is invalid.");
353 minQuorumConnectedStakeRatio = double(megaMinRatio) / 1000000;
356 if (minQuorumConnectedStakeRatio < 0 || minQuorumConnectedStakeRatio > 1) {
358 "The avalanche min quorum connected stake ratio is out of range.");
363 argsman.
GetIntArg(
"-avaminavaproofsnodecount",
366 error =
_(
"The minimum number of node that sent avaproofs message "
367 "should be non-negative");
376 "greater than or equal to %d"),
382 "than or equal to %d"),
383 std::numeric_limits<uint32_t>::max());
390 error =
_(
"The avalanche stale vote factor must be greater than 0");
394 error =
strprintf(
_(
"The avalanche stale vote factor must be less than "
396 std::numeric_limits<uint32_t>::max());
403 return std::unique_ptr<Processor>(
new Processor(
408 stakeUtxoDustThreshold,
411 argsman.
GetBoolArg(
"-avalanchestakingpreconsensus",
416 return item.valueless_by_exception() ||
421 [](
const auto &item) {
return item ==
nullptr; },
440 ->insert(std::make_pair(item,
VoteRecord(accepted)))
452 if (peerManager->forPeer(proof->getId(), [&](
const Peer &peer) {
453 peerid = peer.peerid;
456 return peerManager->setFinalized(peerid);
469 auto it = r->find(item);
474 return it->second.isAccepted();
483 auto it = r->find(item);
488 return it->second.getConfidence();
497 auto it = r->find(item);
498 return it != r.
end();
511 finalizedItems.reset();
524 TCPResponse(Response responseIn,
const CKey &key)
528 const uint256 hash = hasher.GetHash();
551 std::vector<VoteItemUpdate> &updates,
552 bool &disconnect, std::string &
error) {
562 peerManager->updateNextRequestTime(
563 nodeid, Now<SteadyMilliseconds>() +
564 std::chrono::milliseconds(
response.getCooldown()));
567 std::vector<CInv> invs;
575 auto it = w->find(std::make_tuple(nodeid,
response.getRound()));
577 error =
"unexpected-ava-response";
581 invs = std::move(it->invs);
586 const std::vector<Vote> &votes =
response.GetVotes();
587 size_t size = invs.size();
588 if (votes.size() != size) {
590 error =
"invalid-ava-response-size";
594 for (
size_t i = 0; i < size; i++) {
595 if (invs[i].hash != votes[i].GetHash()) {
597 error =
"invalid-ava-response-content";
602 std::map<AnyVoteItem, Vote, VoteMapComparator> responseItems;
606 for (
size_t i = 0; i < size; i++) {
619 responseItems.insert(std::make_pair(std::move(item), votes[i]));
625 for (
const auto &p : responseItems) {
627 const Vote &v = p.second;
629 auto it = voteRecordsWriteView->find(item);
630 if (it == voteRecordsWriteView.end()) {
635 auto &vr = it->second;
636 if (!vr.registerVote(nodeid, v.
GetError())) {
642 voteRecordsWriteView->erase(it);
648 if (!vr.hasFinalized()) {
651 updates.emplace_back(std::move(item), vr.isAccepted()
659 updates.emplace_back(std::move(item), vr.isAccepted()
662 voteRecordsWriteView->erase(it);
667 for (
const auto &update : updates) {
673 const auto &item = update.getVoteItem();
675 if (!std::holds_alternative<const CBlockIndex *>(item)) {
691 const CBlockIndex *pindex = std::get<const CBlockIndex *>(item);
693 if (finalizationTip &&
694 finalizationTip->GetAncestor(pindex->
nHeight) == pindex) {
698 finalizationTip = pindex;
714 if (!delayedAvahelloNodeIds.emplace(pfrom->
GetId()).second) {
724 hasher << delegation.
getId();
751 auto it = delayedAvahelloNodeIds.begin();
752 while (it != delayedAvahelloNodeIds.end()) {
758 it = delayedAvahelloNodeIds.erase(it);
796 if (peerManager->latchAvaproofsSent(nodeid)) {
810 if (peerManager->getNodeCount() < 8) {
843 uint32_t totalPeersScore;
844 uint32_t connectedPeersScore;
847 totalPeersScore = peerManager->getTotalPeersScore();
848 connectedPeersScore = peerManager->getConnectedPeersScore();
853 peerManager->forPeer(localProof->getId(), [](
const Peer &peer) {
854 return peer.node_count == 0;
856 connectedPeersScore += localProof->getScore();
866 uint32_t minConnectedScore =
868 if (connectedPeersScore < minConnectedScore) {
877 bool computedRewards =
false;
926 bool rewardsInserted =
false;
928 pindex, _stakingRewards.
winners))) {
933 .emplace(pindex->
GetBlockHash(), std::move(_stakingRewards))
942 return rewardsInserted;
947 return stakingRewards.erase(prevBlockHash) > 0;
959 for (
auto it = stakingRewards.begin(); it != stakingRewards.end();) {
960 if (it->second.blockheight < minHeight) {
961 it = stakingRewards.erase(it);
970 return peerManager->cleanupStakeContenders(minHeight));
976 std::vector<std::pair<ProofId, CScript>> &winners)
const {
978 auto it = stakingRewards.find(prevBlockHash);
979 if (it == stakingRewards.end()) {
983 winners = it->second.winners;
988 std::vector<CScript> &payouts)
const {
989 std::vector<std::pair<ProofId, CScript>> winners;
995 payouts.reserve(winners.size());
996 for (
auto &winner : winners) {
997 payouts.push_back(std::move(winner.second));
1004 const std::vector<CScript> &payouts) {
1010 stakingReward.
winners.reserve(payouts.size());
1011 for (
const CScript &payout : payouts) {
1017 peerManager->setStakeContenderWinners(pprev, payouts);
1021 return stakingRewards.insert_or_assign(pprev->
GetBlockHash(), stakingReward)
1027 const std::vector<std::pair<ProofId, CScript>> &winners) {
1032 stakingReward.
winners = winners;
1035 return stakingRewards.insert_or_assign(pprev->
GetBlockHash(), stakingReward)
1055 contenderId, prevblockhash));
1058 std::vector<std::pair<ProofId, CScript>> winners;
1060 if (winners.size() == 0) {
1072 peerManager->acceptStakeContender(contenderId);
1079 std::vector<std::pair<ProofId, CScript>> winners;
1082 peerManager->finalizeStakeContender(contenderId, prevblockhash,
1087 if (winners.size() > 0) {
1099 peerManager->rejectStakeContender(contenderId);
1113 peerManager->promoteStakeContendersToBlock(pprev);
1118 std::vector<StakeContenderId> pollableContenders;
1128 std::vector<StakeContenderId> &pollableContenders) {
1130 std::vector<std::pair<ProofId, CScript>> winners;
1134 return peerManager->setContenderStatusForLocalWinners(
1140 auto registerProofs = [&]() {
1143 auto registeredProofs = peerManager->updatedBlockTip();
1147 if (peerManager->registerProof(
peerData->proof, localProofState)) {
1148 registeredProofs.insert(
peerData->proof);
1159 if (peerManager->isImmature(localProofId)) {
1163 if (peerManager->isInConflictingPool(localProofId)) {
1166 "conflicting-utxos");
1168 if (peerManager->isBoundToPeer(localProofId)) {
1174 peerData->proofState = std::move(localProofState));
1177 return registeredProofs;
1180 auto registeredProofs = registerProofs();
1181 for (
const auto &proof : registeredProofs) {
1232 uint64_t current_round =
round++;
1236 auto timeout = Now<SteadyMilliseconds>() +
1240 {pnode->
GetId(), current_round, timeout, invs});
1242 peerManager->updateNextRequestTime(pnode->
GetId(), timeout);
1251 Poll(current_round, std::move(invs))));
1261 peerManager->removeNode(nodeid);
1264 nodeid = peerManager->selectNode();
1269 auto now = Now<SteadyMilliseconds>();
1270 std::map<CInv, uint8_t> timedout_items{};
1276 while (it != w->get<
query_timeout>().end() && it->timeout < now) {
1277 for (
const auto &i : it->invs) {
1278 timedout_items[i]++;
1285 if (timedout_items.empty()) {
1291 for (
const auto &p : timedout_items) {
1298 auto it = voteRecordsWriteView->find(item);
1299 if (it == voteRecordsWriteView.end()) {
1303 it->second.clearInflightRequest(p.second);
1308 std::vector<CInv> invs;
1313 for (
auto it = w->begin(); it != w->end();) {
1336 for (
const auto &[item, voteRecord] : r) {
1343 const bool shouldPoll =
1344 forPoll ? voteRecord.registerPoll() : voteRecord.shouldPoll();
1350 invs.emplace_back(std::visit(buildInvFromVoteItem, item));
1378 return conflicting.GetTx(TxId(inv.hash));
1392 if (pindex->nStatus.isInvalid()) {
1400 pindex->
nHeight) == pindex)) {
1407 return processor.invalidatedBlocks.contains(
1421 const ProofId &proofid = proof->getId();
1423 LOCK(processor.cs_peerManager);
1426 return processor.peerManager->isBoundToPeer(proofid) ||
1427 processor.peerManager->isInConflictingPool(proofid);
1436 return processor.getStakeContenderStatus(contenderId) != -1;
1440 if (!processor.mempool) {
1446 return processor.mempool->isWorthPolling(tx));
1459 return processor.chainman.ActiveChain().Contains(pindex));
1466 processor.cs_peerManager,
1467 return processor.peerManager->isBoundToPeer(proof->getId()));
1475 return processor.getStakeContenderStatus(contenderId) == 0;
1480 if (!processor.mempool) {
1487 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 bool DEFAULT_AVALANCHE_STAKING_PRECONSENSUS
Default for -avalanchestakingpreconsensus.
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.
fs::path GetDataDirNet() const
Get data directory path with appended network identifier.
bool IsArgSet(const std::string &strArg) const
Return true if the given argument has been manually set.
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
bool ForNode(NodeId id, std::function< bool(CNode *pnode)> func)
size_t GetNodeCount(ConnectionDirection) const
void PushMessage(CNode *pnode, CSerializedNetMsg &&msg)
Inv(ventory) message data.
bool IsMsgStakeContender() const
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.
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
auto withConflicting(Callable &&func) const EXCLUSIVE_LOCKS_REQUIRED(!cs_conflicting)
Provides an interface for creating and interacting with one or two chainstates: an IBD chainstate gen...
bool IsInitialBlockDownload() const
Check whether we are doing an initial block download (synchronizing from disk or network)
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 DelegationId & getId() const
const CPubKey & getDelegatedPubkey() const
const LimitedProofId & getLimitedProofId() 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 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.
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)
void setRecentlyFinalized(const uint256 &itemId) EXCLUSIVE_LOCKS_REQUIRED(!cs_finalizedItems)
bool startEventLoop(CScheduler &scheduler)
bool isQuorumEstablished() LOCKS_EXCLUDED(cs_main) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
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
bool isPolled(const AnyVoteItem &item) const
Mutex cs_delayedAvahelloNodeIds
bool setStakingRewardWinners(const CBlockIndex *pprev, const std::vector< CScript > &payouts) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards
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.
bool getStakingRewardWinners(const BlockHash &prevBlockHash, std::vector< std::pair< ProofId, CScript > > &winners) const EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
std::atomic< bool > m_canShareLocalProof
void cleanupStakingRewards(const int minHeight) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards
bool isAccepted(const AnyVoteItem &item) const
ProofRef getLocalProof() const
void acceptStakeContender(const StakeContenderId &contenderId) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
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...
int getStakeContenderStatus(const StakeContenderId &contenderId) const EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
Track votes on stake contenders.
const uint32_t staleVoteFactor
void promoteAndPollStakeContenders(const CBlockIndex *pprev) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards
Promote stake contender cache entries to a given block and then poll.
void sendDelayedAvahello() EXCLUSIVE_LOCKS_REQUIRED(!cs_delayedAvahelloNodeIds)
void finalizeStakeContender(const StakeContenderId &contenderId) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
std::unique_ptr< PeerData > peerData
bool eraseStakingRewardWinner(const BlockHash &prevBlockHash) EXCLUSIVE_LOCKS_REQUIRED(!cs_stakingRewards)
const bool m_stakingPreConsensus
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, bool stakingPreConsensus)
ChainstateManager & chainman
std::atomic< int64_t > avaproofsNodeCounter
bool computeStakingReward(const CBlockIndex *pindex) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
ProofRegistrationState getLocalProofRegistrationState() const
bool registerVotes(NodeId nodeid, const Response &response, std::vector< VoteItemUpdate > &updates, bool &disconnect, std::string &error) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager
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 rejectStakeContender(const StakeContenderId &contenderId) EXCLUSIVE_LOCKS_REQUIRED(!cs_peerManager)
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::variant< const ProofRef, const CBlockIndex *, const StakeContenderId, const CTransactionRef > AnyVoteItem
@ INVALID_STAKE_SIGNATURE
static bool VerifyDelegation(const Delegation &dg, const CPubKey &expectedPubKey, bilingual_str &error)
static bool isNull(const AnyVoteItem &item)
static bool VerifyProof(const Amount &stakeUtxoDustThreshold, const Proof &proof, bilingual_str &error)
static uint256 GetVoteItemId(const AnyVoteItem &item)
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 size_t AVALANCHE_CONTENDER_MAX_POLLABLE
Maximum number of stake contenders to poll for, leaving room for polling blocks and proofs in the sam...
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.
@ MSG_AVA_STAKE_CONTENDER
#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)
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
StakeContenderIds are unique for each block to ensure that the peer polling for their acceptance has ...
#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.
bool ParseFixedPoint(std::string_view val, int decimals, int64_t *amount_out)
Parse number as fixed point according to JSON number syntax.
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.