NegativeUNLVote.h

#pragma once
 
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/PublicKey.h>
#include <xrpl/protocol/UintTypes.h>
 
#include <optional>
 
namespace xrpl {
 
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 kNegativeUnlLowWaterMark = kFlagLedgerInterval * 50 / 100;
    static constexpr size_t kNegativeUnlHighWaterMark = kFlagLedgerInterval * 80 / 100;
    static constexpr size_t kNegativeUnlMinLocalValsToVote = kFlagLedgerInterval * 90 / 100;
    static constexpr size_t kNewValidatorDisableSkip = kFlagLedgerInterval * 2;
    static constexpr float kNegativeUnlMaxListed = 0.25;

    enum class 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);

    static 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
    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 xrpl