ConsensusTypes.h

#pragma once
 
#include <xrpld/consensus/ConsensusProposal.h>
#include <xrpld/consensus/DisputedTx.h>
 
#include <xrpl/basics/chrono.h>
 
#include <chrono>
#include <map>
 
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;
};

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