ConsensusParms.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <chrono>
#include <cstddef>
#include <functional>
#include <map>
#include <optional>
 
namespace xrpl {
 
struct ConsensusParms
{
    explicit ConsensusParms() = default;
 
    //-------------------------------------------------------------------------
    // Validation and proposal durations are relative to NetClock times, so use
    // second resolution
    std::chrono::seconds const validationVALID_WALL = std::chrono::minutes{5};
 
    std::chrono::seconds const validationVALID_LOCAL = std::chrono::minutes{3};
 
    std::chrono::seconds const validationVALID_EARLY = 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 minCONSENSUS_PCT = 80;
 
    std::chrono::milliseconds const ledgerIDLE_INTERVAL = std::chrono::seconds{15};
 
    std::chrono::milliseconds const ledgerMIN_CONSENSUS = std::chrono::milliseconds{1950};
 
    std::chrono::milliseconds const ledgerMAX_CONSENSUS = std::chrono::seconds{15};
 
    std::chrono::milliseconds const ledgerMIN_CLOSE = std::chrono::seconds{2};
 
    std::chrono::milliseconds const ledgerGRANULARITY = std::chrono::seconds{1};
 
    std::size_t const ledgerABANDON_CONSENSUS_FACTOR = 10;
 
    std::chrono::milliseconds const ledgerABANDON_CONSENSUS = std::chrono::seconds{120};
 
    std::chrono::milliseconds const avMIN_CONSENSUS_TIME = 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 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
        {init, {0, 50, mid}},
        // mid-consensus starts after 50% of the previous round time, and
        // requires 65% yes
        {mid, {50, 65, late}},
        // late consensus starts after 85% time, and requires 70% yes
        {late, {85, 70, stuck}},
        // we're stuck after 2x time, requires 95% yes votes
        {stuck, {200, 95, stuck}},
    };
 
    std::size_t const avCT_CONSENSUS_PCT = 75;
 
    // (Moving to the next avalanche level, considering that votes are stalled
    // without consensus.)
    std::size_t const avMIN_ROUNDS = 2;
 
    std::size_t const avSTALLED_ROUNDS = 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