ConsensusTypes.h

#pragma once
 
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/consensus/ConsensusProposal.h>
#include <xrpl/consensus/DisputedTx.h>
 
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <map>
#include <optional>
#include <string>
 
namespace xrpl {

enum class ConsensusMode {
    Proposing,
    Observing,
    WrongLedger,
    SwitchedLedger
};
 
inline std::string
to_string(ConsensusMode m)
{
    switch (m)
    {
        case ConsensusMode::Proposing:
            return "proposing";
        case ConsensusMode::Observing:
            return "observing";
        case ConsensusMode::WrongLedger:
            return "wrongLedger";
        case ConsensusMode::SwitchedLedger:
            return "switchedLedger";
        default:
            return "unknown";
    }
}

enum class ConsensusPhase {
    Open,

    Establish,

    Accepted,
};
 
inline std::string
to_string(ConsensusPhase p)
{
    switch (p)
    {
        case ConsensusPhase::Open:
            return "open";
        case ConsensusPhase::Establish:
            return "establish";
        case ConsensusPhase::Accepted:
            return "accepted";
        default:
            return "unknown";
    }
}

class ConsensusTimer
{
    using time_point = std::chrono::steady_clock::time_point;
    time_point start_;
    std::chrono::milliseconds dur_{};
 
public:
    [[nodiscard]] std::chrono::milliseconds
    read() const
    {
        return dur_;
    }
 
    void
    tick(std::chrono::milliseconds fixed)
    {
        dur_ += fixed;
    }
 
    void
    reset(time_point tp)
    {
        start_ = tp;
        dur_ = std::chrono::milliseconds{0};
    }
 
    void
    tick(time_point tp)
    {
        using namespace std::chrono;
        dur_ = duration_cast<milliseconds>(tp - start_);
    }
};

struct ConsensusCloseTimes
{
    explicit ConsensusCloseTimes() = default;

    std::map<NetClock::time_point, int> peers;

    NetClock::time_point self;
};

inline std::chrono::seconds
medianCloseOffset(ConsensusCloseTimes const& times)
{
    using namespace std::chrono;
    using time_point = NetClock::time_point;
 
    std::int64_t totalWeight = 1;
    for (auto const& [_, w] : times.peers)
        totalWeight += w;
 
    std::int64_t const halfWeight = (totalWeight + 1) / 2;
 
    std::optional<time_point> median{};
    std::int64_t tally = 0;
    bool selfPlaced = false;
 
    // Accumulate weight in time order; the first bin to reach halfWeight is
    // the (lower) weighted median. Returns true once that bin is found.
    auto step = [&](time_point t, std::int64_t w) {
        XRPL_ASSERT(tally < halfWeight, "xrpl::medianCloseOffset::step : median not yet found");
        tally += w;
        if (tally >= halfWeight)
        {
            median = t;
            return true;
        }
        return false;
    };
 
    for (auto const& [t, w] : times.peers)
    {
        if (!selfPlaced && times.self <= t)
        {
            selfPlaced = true;
            if (step(times.self, 1))
                break;
        }
        if (step(t, w))
            break;
    }
    if (!selfPlaced && !median)
        step(times.self, 1);
 
    if (!median)
    {
        // LCOV_EXCL_START
        UNREACHABLE("xrpl::medianCloseOffset : median not found");
        median = times.self;
        // LCOV_EXCL_STOP
    }
 
    return duration_cast<seconds>(
        duration<std::int64_t>{median->time_since_epoch().count()} -
        duration<std::int64_t>{times.self.time_since_epoch().count()});
}

enum class ConsensusState {
    No,       
    MovedOn,  
    Expired,  
    Yes       
};

template <class Traits>
struct ConsensusResult
{
    using Ledger_t = Traits::Ledger_t;
    using TxSet_t = Traits::TxSet_t;
    using NodeID_t = Traits::NodeID_t;
 
    using Tx_t = TxSet_t::Tx;
    using Proposal_t = ConsensusProposal<NodeID_t, typename Ledger_t::ID, typename TxSet_t::ID>;
    using Dispute_t = DisputedTx<Tx_t, NodeID_t>;
 
    ConsensusResult(TxSet_t&& s, Proposal_t&& p) : txns{std::move(s)}, position{std::move(p)}
    {
        XRPL_ASSERT(txns.id() == position.position(), "xrpl::ConsensusResult : valid inputs");
    }

    TxSet_t txns;

    Proposal_t position;

    hash_map<typename Tx_t::ID, Dispute_t> disputes;
 
    // Set of TxSet ids we have already compared/created disputes
    hash_set<typename TxSet_t::ID> compares;
 
    // Measures the duration of the establish phase for this consensus round
    ConsensusTimer roundTime;
 
    // Indicates state in which consensus ended.  Once in the accept phase
    // will be either Yes or MovedOn or Expired
    ConsensusState state = ConsensusState::No;
 
    // The number of peers proposing during the round
    std::size_t proposers = 0;
};
}  // namespace xrpl