peermanager.h

Go to the documentation of this file.

// Copyright (c) 2020 The Bitcoin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#ifndef BITCOIN_AVALANCHE_PEERMANAGER_H
#define BITCOIN_AVALANCHE_PEERMANAGER_H
 
#include <avalanche/node.h>
#include <avalanche/proof.h>
#include <avalanche/proofpool.h>
#include <avalanche/proofradixtreeadapter.h>
#include <avalanche/protocol.h>
#include <avalanche/stakecontendercache.h>
#include <coins.h>
#include <common/bloom.h>
#include <consensus/validation.h>
#include <radix.h>
#include <util/fs.h>
#include <util/hasher.h>
#include <util/time.h>
 
#include <boost/multi_index/composite_key.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index_container.hpp>
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <vector>
 
class ChainstateManager;
class CScheduler;
 
namespace avalanche {
 
static constexpr uint32_t AVALANCHE_MAX_IMMATURE_PROOFS = 4000;
 
class Delegation;
 
namespace {
    struct TestPeerManager;
}
 
struct Slot {
private:
    uint64_t start;
    uint32_t score;
    PeerId peerid;
 
public:
    Slot(uint64_t startIn, uint32_t scoreIn, PeerId peeridIn)
        : start(startIn), score(scoreIn), peerid(peeridIn) {}
 
    Slot withStart(uint64_t startIn) const {
        return Slot(startIn, score, peerid);
    }
    Slot withScore(uint64_t scoreIn) const {
        return Slot(start, scoreIn, peerid);
    }
    Slot withPeerId(PeerId peeridIn) const {
        return Slot(start, score, peeridIn);
    }
 
    uint64_t getStart() const { return start; }
    uint64_t getStop() const { return start + score; }
    uint32_t getScore() const { return score; }
    PeerId getPeerId() const { return peerid; }
 
    bool contains(uint64_t slot) const {
        return getStart() <= slot && slot < getStop();
    }
    bool precedes(uint64_t slot) const { return slot >= getStop(); }
    bool follows(uint64_t slot) const { return getStart() > slot; }
};
 
struct Peer {
    PeerId peerid;
    uint32_t index = -1;
    uint32_t node_count = 0;
 
    ProofRef proof;
    bool hasFinalized = false;
 
    // The network stack uses timestamp in seconds, so we oblige.
    std::chrono::seconds registration_time;
    std::chrono::seconds nextPossibleConflictTime;
 
    static constexpr auto DANGLING_TIMEOUT = 15min;
 
    Peer(PeerId peerid_, ProofRef proof_,
         std::chrono::seconds nextPossibleConflictTime_)
        : peerid(peerid_), proof(std::move(proof_)),
          registration_time(GetTime<std::chrono::seconds>()),
          nextPossibleConflictTime(std::move(nextPossibleConflictTime_)) {}
 
    const ProofId &getProofId() const { return proof->getId(); }
    uint32_t getScore() const { return proof->getScore(); }
};
 
struct proof_index {
    using result_type = ProofId;
    result_type operator()(const Peer &p) const { return p.proof->getId(); }
};
 
struct score_index {
    using result_type = uint32_t;
    result_type operator()(const Peer &p) const { return p.getScore(); }
};
 
struct next_request_time {};
 
struct PendingNode {
    ProofId proofid;
    NodeId nodeid;
    size_t max_elements;
 
    PendingNode(ProofId proofid_, NodeId nodeid_, size_t max_elements_)
        : proofid(proofid_), nodeid(nodeid_), max_elements(max_elements_){};
};
 
struct by_proofid;
struct by_nodeid;
struct by_score;
 
struct RemoteProof {
    ProofId proofid;
    NodeId nodeid;
    std::chrono::seconds lastUpdate;
    bool present;
};
 
enum class ProofRegistrationResult {
    NONE = 0,
    ALREADY_REGISTERED,
    IMMATURE,
    INVALID,
    CONFLICTING,
    REJECTED,
    COOLDOWN_NOT_ELAPSED,
    DANGLING,
    MISSING_UTXO,
};
 
class ProofRegistrationState : public ValidationState<ProofRegistrationResult> {
};
 
namespace bmi = boost::multi_index;
 
class PeerManager {
    std::vector<Slot> slots;
    uint64_t slotCount = 0;
    uint64_t fragmentation = 0;
 
    using PeerSet = boost::multi_index_container<
        Peer, bmi::indexed_by<
                  // index by peerid
                  bmi::hashed_unique<bmi::member<Peer, PeerId, &Peer::peerid>>,
                  // index by proof
                  bmi::hashed_unique<bmi::tag<by_proofid>, proof_index,
                                     SaltedProofIdHasher>,
                  // ordered by score, decreasing order
                  bmi::ordered_non_unique<bmi::tag<by_score>, score_index,
                                          std::greater<uint32_t>>>>;
 
    PeerId nextPeerId = 0;
    PeerSet peers;
 
    ProofPool validProofPool;
    ProofPool conflictingProofPool;
    ProofPool immatureProofPool;
    ProofPool danglingProofPool;
 
    using ProofRadixTree = RadixTree<const Proof, ProofRadixTreeAdapter>;
    ProofRadixTree shareableProofs;
 
    using NodeSet = boost::multi_index_container<
        Node, bmi::indexed_by<
                  // index by nodeid
                  bmi::hashed_unique<bmi::member<Node, NodeId, &Node::nodeid>>,
                  // sorted by peerid/nextRequestTime
                  bmi::ordered_non_unique<
                      bmi::tag<next_request_time>,
                      bmi::composite_key<
                          Node, bmi::member<Node, PeerId, &Node::peerid>,
                          bmi::member<Node, SteadyMilliseconds,
                                      &Node::nextRequestTime>>>>>;
 
    NodeSet nodes;
 
    std::atomic<bool> needMoreNodes{false};
 
    using PendingNodeSet = boost::multi_index_container<
        PendingNode,
        bmi::indexed_by<
            // index by proofid
            bmi::hashed_non_unique<
                bmi::tag<by_proofid>,
                bmi::member<PendingNode, ProofId, &PendingNode::proofid>,
                SaltedProofIdHasher>,
            // index by nodeid
            bmi::hashed_unique<
                bmi::tag<by_nodeid>,
                bmi::member<PendingNode, NodeId, &PendingNode::nodeid>>>>;
    PendingNodeSet pendingNodes;
 
    static constexpr int SELECT_PEER_MAX_RETRY = 3;
    static constexpr int SELECT_NODE_MAX_RETRY = 3;
 
    ProofIdSet m_unbroadcast_proofids;
 
    uint32_t totalPeersScore = 0;
    uint32_t connectedPeersScore = 0;
 
    Amount stakeUtxoDustThreshold;
 
    ChainstateManager &chainman;
 
    const bool m_stakingPreConsensus{false};
 
    ProofRef localProof;
 
    struct by_lastUpdate;
 
    using RemoteProofSet = boost::multi_index_container<
        RemoteProof,
        bmi::indexed_by<
            // index by proofid/nodeid pair
            bmi::hashed_unique<
                bmi::composite_key<
                    RemoteProof,
                    bmi::member<RemoteProof, ProofId, &RemoteProof::proofid>,
                    bmi::member<RemoteProof, NodeId, &RemoteProof::nodeid>>,
                bmi::composite_key_hash<SaltedProofIdHasher,
                                        boost::hash<NodeId>>>,
            // index by proofid
            bmi::hashed_non_unique<
                bmi::tag<by_proofid>,
                bmi::member<RemoteProof, ProofId, &RemoteProof::proofid>,
                SaltedProofIdHasher>,
            // index by nodeid
            bmi::hashed_non_unique<
                bmi::tag<by_nodeid>,
                bmi::member<RemoteProof, NodeId, &RemoteProof::nodeid>>,
            bmi::ordered_non_unique<
                bmi::tag<by_lastUpdate>,
                bmi::composite_key<
                    RemoteProof,
                    bmi::member<RemoteProof, NodeId, &RemoteProof::nodeid>,
                    bmi::member<RemoteProof, std::chrono::seconds,
                                &RemoteProof::lastUpdate>>>>>;
 
    RemoteProofSet remoteProofs;
 
    CRollingBloomFilter invalidProofs{100000, 0.000001};
 
    std::unordered_set<ProofId, SaltedProofIdHasher> manualFlakyProofids;
 
    StakeContenderCache stakeContenderCache;
 
public:
    static constexpr size_t MAX_REMOTE_PROOFS{100};
 
    PeerManager(const Amount &stakeUtxoDustThresholdIn,
                ChainstateManager &chainmanIn, bool stakingPreConsensus = false,
                const ProofRef &localProofIn = ProofRef())
        : stakeUtxoDustThreshold(stakeUtxoDustThresholdIn),
          chainman(chainmanIn), m_stakingPreConsensus(stakingPreConsensus),
          localProof(localProofIn){};
 
    bool addNode(NodeId nodeid, const ProofId &proofid, size_t max_elements);
    bool removeNode(NodeId nodeid);
    size_t getNodeCount() const { return nodes.size(); }
    size_t getPendingNodeCount() const { return pendingNodes.size(); }
 
    // Update when a node is to be polled next.
    bool updateNextRequestTimeForPoll(NodeId nodeid, SteadyMilliseconds timeout,
                                      uint64_t round);
    bool updateNextRequestTimeForResponse(NodeId nodeid,
                                          const Response &response);
    bool latchAvaproofsSent(NodeId nodeid);
 
    // Randomly select a node to poll.
    NodeId selectNode();
 
    bool shouldRequestMoreNodes() { return needMoreNodes.exchange(false); }
 
    template <typename Callable>
    bool forNode(NodeId nodeid, Callable &&func) const {
        auto it = nodes.find(nodeid);
        return it != nodes.end() && func(*it);
    }
 
    template <typename Callable>
    void forEachNode(const Peer &peer, Callable &&func) const {
        auto &nview = nodes.get<next_request_time>();
        auto range = nview.equal_range(peer.peerid);
        for (auto it = range.first; it != range.second; ++it) {
            func(*it);
        }
    }
 
    bool updateNextPossibleConflictTime(PeerId peerid,
                                        const std::chrono::seconds &nextTime);
 
    bool setFinalized(PeerId peerid);
 
    enum class RegistrationMode {
        DEFAULT,
        FORCE_ACCEPT,
    };
 
    bool registerProof(const ProofRef &proof,
                       ProofRegistrationState &registrationState,
                       RegistrationMode mode = RegistrationMode::DEFAULT);
    bool registerProof(const ProofRef &proof,
                       RegistrationMode mode = RegistrationMode::DEFAULT) {
        ProofRegistrationState dummy;
        return registerProof(proof, dummy, mode);
    }
 
    enum class RejectionMode {
        DEFAULT,
        INVALIDATE,
    };
 
    bool rejectProof(const ProofId &proofid,
                     RejectionMode mode = RejectionMode::DEFAULT);
 
    bool exists(const ProofId &proofid) const {
        return getProof(proofid) != nullptr;
    }
 
    void cleanupDanglingProofs(
        std::unordered_set<ProofRef, SaltedProofHasher> &registeredProofs);
 
    template <typename Callable>
    bool forPeer(const ProofId &proofid, Callable &&func) const {
        auto &pview = peers.get<by_proofid>();
        auto it = pview.find(proofid);
        return it != pview.end() && func(*it);
    }
 
    template <typename Callable> void forEachPeer(Callable &&func) const {
        for (const auto &p : peers) {
            func(p);
        }
    }
 
    std::unordered_set<ProofRef, SaltedProofHasher> updatedBlockTip();
 
    void addUnbroadcastProof(const ProofId &proofid);
    void removeUnbroadcastProof(const ProofId &proofid);
    auto getUnbroadcastProofs() const { return m_unbroadcast_proofids; }
 
    /*
     * Quorum management
     */
    uint32_t getTotalPeersScore() const { return totalPeersScore; }
    uint32_t getConnectedPeersScore() const { return connectedPeersScore; }
 
    bool saveRemoteProof(const ProofId &proofid, const NodeId nodeid,
                         const bool present);
    std::vector<RemoteProof> getRemoteProofs(const NodeId nodeid) const;
    bool hasRemoteProofStatus(const ProofId &proofid) const;
    bool isRemotelyPresentProof(const ProofId &proofid) const;
 
    bool setFlaky(const ProofId &proofid);
    bool unsetFlaky(const ProofId &proofid);
    template <typename Callable> void forEachFlakyProof(Callable &&func) const {
        for (const auto &p : manualFlakyProofids) {
            func(p);
        }
    }
 
    void cleanupStakeContenders(const int requestedMinHeight);
    void addStakeContender(const ProofRef &proof);
    int getStakeContenderStatus(const StakeContenderId &contenderId,
                                BlockHash &prevblockhashout) const;
    void acceptStakeContender(const StakeContenderId &contenderId);
    void finalizeStakeContender(
        const StakeContenderId &contenderId, BlockHash &prevblockhash,
        std::vector<std::pair<ProofId, CScript>> &newWinners);
    void rejectStakeContender(const StakeContenderId &contenderId);
    void promoteStakeContendersToBlock(const CBlockIndex *pindex);
    bool setContenderStatusForLocalWinners(
        const CBlockIndex *prevblock,
        const std::vector<std::pair<ProofId, CScript>> winners,
        size_t maxPollable, std::vector<StakeContenderId> &pollableContenders);
    bool setStakeContenderWinners(const CBlockIndex *pindex,
                                  const std::vector<CScript> &payoutScripts);
 
    /****************************************************
     * Functions which are public for testing purposes. *
     ****************************************************/
 
    bool removePeer(const PeerId peerid);
 
    PeerId selectPeer() const;
 
    uint64_t compact();
 
    bool verify() const;
 
    // Accessors.
    uint64_t getSlotCount() const { return slotCount; }
    uint64_t getFragmentation() const { return fragmentation; }
 
    const ProofPool &getValidProofPool() const { return validProofPool; }
    const ProofPool &getConflictingProofPool() const {
        return conflictingProofPool;
    }
    const ProofPool &getImmatureProofPool() const { return immatureProofPool; }
 
    ProofRef getProof(const ProofId &proofid) const;
    bool isBoundToPeer(const ProofId &proofid) const;
    bool isImmature(const ProofId &proofid) const;
    bool isInConflictingPool(const ProofId &proofid) const;
    bool isDangling(const ProofId &proofid) const;
 
    void setInvalid(const ProofId &proofid);
    bool isInvalid(const ProofId &proofid) const;
    void clearAllInvalid();
 
    const ProofRadixTree &getShareableProofsSnapshot() const {
        return shareableProofs;
    }
 
    const Amount &getStakeUtxoDustThreshold() const {
        return stakeUtxoDustThreshold;
    }
 
    bool selectStakingRewardWinner(
        const CBlockIndex *pprev,
        std::vector<std::pair<ProofId, CScript>> &winners);
 
    bool dumpPeersToFile(const fs::path &dumpPath) const;
    bool loadPeersFromFile(
        const fs::path &dumpPath,
        std::unordered_set<ProofRef, SaltedProofHasher> &registeredProofs);
 
private:
    template <typename ProofContainer>
    void moveToConflictingPool(const ProofContainer &proofs);
 
    bool addOrUpdateNode(const PeerSet::iterator &it, NodeId nodeid,
                         size_t max_elements);
    bool addNodeToPeer(const PeerSet::iterator &it);
    bool removeNodeFromPeer(const PeerSet::iterator &it, uint32_t count = 1);
 
    std::optional<bool> getRemotePresenceStatus(const ProofId &proofid) const;
 
    bool isFlaky(const ProofId &proofid) const;
 
    bool isStakingPreconsensusActivated() const {
        return m_stakingPreConsensus;
    }
 
    friend struct ::avalanche::TestPeerManager;
};
 
PeerId selectPeerImpl(const std::vector<Slot> &slots, const uint64_t slot,
                      const uint64_t max);
 
} // namespace avalanche
 
#endif // BITCOIN_AVALANCHE_PEERMANAGER_H