LedgerTiming.h

#pragma once
 
#include <xrpl/beast/utility/instrumentation.h>
 
#include <algorithm>
#include <chrono>
#include <iterator>
 
namespace xrpl {

constexpr std::chrono::seconds kLedgerPossibleTimeResolutions[] = {
    std::chrono::seconds{10},
    std::chrono::seconds{20},
    std::chrono::seconds{30},
    std::chrono::seconds{60},
    std::chrono::seconds{90},
    std::chrono::seconds{120}};

constexpr auto kLedgerDefaultTimeResolution = kLedgerPossibleTimeResolutions[2];

constexpr auto kLedgerGenesisTimeResolution = kLedgerPossibleTimeResolutions[0];

constexpr auto kIncreaseLedgerTimeResolutionEvery = 8;

constexpr auto kDecreaseLedgerTimeResolutionEvery = 1;

template <class Rep, class Period, class Seq>
std::chrono::duration<Rep, Period>
getNextLedgerTimeResolution(
    std::chrono::duration<Rep, Period> previousResolution,
    bool previousAgree,
    Seq ledgerSeq)
{
    XRPL_ASSERT(ledgerSeq != Seq{0}, "xrpl::getNextLedgerTimeResolution : valid ledger sequence");
 
    using namespace std::chrono;
    // Find the current resolution:
    auto iter = std::find(
        std::begin(kLedgerPossibleTimeResolutions),
        std::end(kLedgerPossibleTimeResolutions),
        previousResolution);
    XRPL_ASSERT(
        iter != std::end(kLedgerPossibleTimeResolutions),
        "xrpl::getNextLedgerTimeResolution : found time resolution");
 
    // This should never happen, but just as a precaution
    if (iter == std::end(kLedgerPossibleTimeResolutions))
        return previousResolution;
 
    // If we did not previously agree, we try to decrease the resolution to
    // improve the chance that we will agree now.
    if (!previousAgree && (ledgerSeq % Seq{kDecreaseLedgerTimeResolutionEvery} == Seq{0}))
    {
        if (++iter != std::end(kLedgerPossibleTimeResolutions))
            return *iter;
    }
 
    // If we previously agreed, we try to increase the resolution to determine
    // if we can continue to agree.
    if (previousAgree && (ledgerSeq % Seq{kIncreaseLedgerTimeResolutionEvery} == Seq{0}))
    {
        if (iter-- != std::begin(kLedgerPossibleTimeResolutions))
            return *iter;
    }
 
    return previousResolution;
}

template <class Clock, class Duration, class Rep, class Period>
std::chrono::time_point<Clock, Duration>
roundCloseTime(
    std::chrono::time_point<Clock, Duration> closeTime,
    std::chrono::duration<Rep, Period> closeResolution)
{
    using time_point = decltype(closeTime);
    if (closeTime == time_point{})
        return closeTime;
 
    closeTime += (closeResolution / 2);
    return closeTime - (closeTime.time_since_epoch() % closeResolution);
}

template <class Clock, class Duration, class Rep, class Period>
std::chrono::time_point<Clock, Duration>
effCloseTime(
    std::chrono::time_point<Clock, Duration> closeTime,
    std::chrono::duration<Rep, Period> resolution,
    std::chrono::time_point<Clock, Duration> priorCloseTime)
{
    using namespace std::chrono_literals;
    using time_point = decltype(closeTime);
 
    if (closeTime == time_point{})
        return closeTime;
 
    return std::max<time_point>(roundCloseTime(closeTime, resolution), (priorCloseTime + 1s));
}
 
}  // namespace xrpl