NegativeUNLVote.h

#ifndef XRPL_APP_MISC_NEGATIVEUNLVOTE_H_INCLUDED
#define XRPL_APP_MISC_NEGATIVEUNLVOTE_H_INCLUDED
 
#include <xrpld/app/ledger/Ledger.h>
 
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/UintTypes.h>
 
#include <optional>
 
namespace ripple {
 
template <class Adaptor>
class Validations;
class RCLValidationsAdaptor;
using RCLValidations = Validations<RCLValidationsAdaptor>;
class SHAMap;
namespace test {
class NegativeUNLVoteInternal_test;
class NegativeUNLVoteScoreTable_test;
}  // namespace test
 
class NegativeUNLVote final
{
public:
    static constexpr size_t negativeUNLLowWaterMark =
        FLAG_LEDGER_INTERVAL * 50 / 100;
    static constexpr size_t negativeUNLHighWaterMark =
        FLAG_LEDGER_INTERVAL * 80 / 100;
    static constexpr size_t negativeUNLMinLocalValsToVote =
        FLAG_LEDGER_INTERVAL * 90 / 100;
    static constexpr size_t newValidatorDisableSkip = FLAG_LEDGER_INTERVAL * 2;
    static constexpr float negativeUNLMaxListed = 0.25;
 
    enum NegativeUNLModify {
        ToDisable,  // UNLModify Tx is to disable a validator
        ToReEnable  // UNLModify Tx is to re-enable a validator
    };
 
    NegativeUNLVote(NodeID const& myId, beast::Journal j);
    ~NegativeUNLVote() = default;
 
    void
    doVoting(
        std::shared_ptr<Ledger const> const& prevLedger,
        hash_set<PublicKey> const& unlKeys,
        RCLValidations& validations,
        std::shared_ptr<SHAMap> const& initialSet);
 
    void
    newValidators(LedgerIndex seq, hash_set<NodeID> const& nowTrusted);
 
private:
    NodeID const myId_;
    beast::Journal j_;
    mutable std::mutex mutex_;
    hash_map<NodeID, LedgerIndex> newValidators_;
 
    struct Candidates
    {
        std::vector<NodeID> toDisableCandidates;
        std::vector<NodeID> toReEnableCandidates;
    };
 
    void
    addTx(
        LedgerIndex seq,
        PublicKey const& vp,
        NegativeUNLModify modify,
        std::shared_ptr<SHAMap> const& initialSet);
 
    NodeID
    choose(uint256 const& randomPadData, std::vector<NodeID> const& candidates);
 
    std::optional<hash_map<NodeID, std::uint32_t>>
    buildScoreTable(
        std::shared_ptr<Ledger const> const& prevLedger,
        hash_set<NodeID> const& unl,
        RCLValidations& validations);
 
    Candidates const
    findAllCandidates(
        hash_set<NodeID> const& unl,
        hash_set<NodeID> const& negUnl,
        hash_map<NodeID, std::uint32_t> const& scoreTable);
 
    void
    purgeNewValidators(LedgerIndex seq);
 
    friend class test::NegativeUNLVoteInternal_test;
    friend class test::NegativeUNLVoteScoreTable_test;
};
 
}  // namespace ripple
 
#endif