ConsensusParms.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <chrono>
#include <cstddef>
#include <map>
#include <optional>
#include <utility>
 
namespace xrpl {

struct ConsensusParms
{
    explicit ConsensusParms() = default;
 
    //-------------------------------------------------------------------------
    // Validation and proposal durations are relative to NetClock times, so use
    // second resolution
    std::chrono::seconds const validationValidWall = std::chrono::minutes{5};

    std::chrono::seconds const validationValidLocal = std::chrono::minutes{3};

    std::chrono::seconds const validationValidEarly = std::chrono::minutes{3};

    std::chrono::seconds const proposeFRESHNESS = std::chrono::seconds{20};

    std::chrono::seconds const proposeINTERVAL = std::chrono::seconds{12};
 
    //-------------------------------------------------------------------------
    // Consensus durations are relative to the internal Consensus clock and use
    // millisecond resolution.

    std::size_t const minConsensusPct = 80;

    std::chrono::milliseconds const ledgerIdleInterval = std::chrono::seconds{15};

    std::chrono::milliseconds const ledgerMinConsensus = std::chrono::milliseconds{1950};

    std::chrono::milliseconds const ledgerMaxConsensus = std::chrono::seconds{15};

    std::chrono::milliseconds const ledgerMinClose = std::chrono::seconds{2};

    std::chrono::milliseconds const ledgerGRANULARITY = std::chrono::seconds{1};

    std::size_t const ledgerAbandonConsensusFactor = 10;

    std::chrono::milliseconds const ledgerAbandonConsensus = std::chrono::seconds{120};

    std::chrono::milliseconds const avMinConsensusTime = std::chrono::seconds{5};
 
    //------------------------------------------------------------------------------
    // Avalanche tuning
    // As a function of the percent this round's duration is of the prior round,
    // we increase the threshold for yes votes to add a transaction to our
    // position.
    enum class AvalancheState { Init, Mid, Late, Stuck };
    struct AvalancheCutoff
    {
        int const consensusTime;
        std::size_t const consensusPct;
        AvalancheState const next;
    };

    std::map<AvalancheState, AvalancheCutoff> const avalancheCutoffs{
        // {state, {time, percent, nextState}},
        // Initial state: 50% of nodes must vote yes
        {AvalancheState::Init,
         {.consensusTime = 0, .consensusPct = 50, .next = AvalancheState::Mid}},
        // mid-consensus starts after 50% of the previous round time, and
        // requires 65% yes
        {AvalancheState::Mid,
         {.consensusTime = 50, .consensusPct = 65, .next = AvalancheState::Late}},
        // late consensus starts after 85% time, and requires 70% yes
        {AvalancheState::Late,
         {.consensusTime = 85, .consensusPct = 70, .next = AvalancheState::Stuck}},
        // we're stuck after 2x time, requires 95% yes votes
        {AvalancheState::Stuck,
         {.consensusTime = 200, .consensusPct = 95, .next = AvalancheState::Stuck}},
    };

    std::size_t const avCtConsensusPct = 75;

    // (Moving to the next avalanche level, considering that votes are stalled
    // without consensus.)
    std::size_t const avMinRounds = 2;

    std::size_t const avStalledRounds = 4;
};
 
inline std::pair<std::size_t, std::optional<ConsensusParms::AvalancheState>>
getNeededWeight(
    ConsensusParms const& p,
    ConsensusParms::AvalancheState currentState,
    int percentTime,
    std::size_t currentRounds,
    std::size_t minimumRounds)
{
    // at() can throw, but the map is built by hand to ensure all valid
    // values are available.
    auto const& currentCutoff = p.avalancheCutoffs.at(currentState);
    // Should we consider moving to the next state?
    if (currentCutoff.next != currentState && currentRounds >= minimumRounds)
    {
        // at() can throw, but the map is built by hand to ensure all
        // valid values are available.
        auto const& nextCutoff = p.avalancheCutoffs.at(currentCutoff.next);
        // See if enough time has passed to move on to the next.
        XRPL_ASSERT(
            nextCutoff.consensusTime >= currentCutoff.consensusTime,
            "xrpl::getNeededWeight : next state valid");
        if (percentTime >= nextCutoff.consensusTime)
        {
            return {nextCutoff.consensusPct, currentCutoff.next};
        }
    }
    return {currentCutoff.consensusPct, {}};
}
 
}  // namespace xrpl