ConsensusProposal.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/HashPrefix.h>
#include <xrpl/protocol/digest.h>
#include <xrpl/protocol/jss.h>
 
#include <cstdint>
#include <optional>
#include <sstream>
#include <string>
 
namespace xrpl {
template <class NodeId, class LedgerId, class Position>
class ConsensusProposal
{
public:
    using NodeID = NodeId;
 
    //< Sequence value when a peer initially joins consensus
    static std::uint32_t const kSeqJoin = 0;
 
    //< Sequence number when  a peer wants to bow out and leave consensus
    static std::uint32_t const kSeqLeave = 0xffffffff;

    ConsensusProposal(
        LedgerId const& prevLedger,
        std::uint32_t seq,
        Position const& position,
        NetClock::time_point closeTime,
        NetClock::time_point now,
        NodeId const& nodeID)
        : previousLedger_(prevLedger)
        , position_(position)
        , closeTime_(closeTime)
        , time_(now)
        , proposeSeq_(seq)
        , nodeID_(nodeID)
    {
    }

    NodeId const&
    nodeID() const
    {
        return nodeID_;
    }

    Position const&
    position() const
    {
        return position_;
    }

    LedgerId const&
    prevLedger() const
    {
        return previousLedger_;
    }

    std::uint32_t
    proposeSeq() const
    {
        return proposeSeq_;
    }

    NetClock::time_point const&
    closeTime() const
    {
        return closeTime_;
    }

    NetClock::time_point const&
    seenTime() const
    {
        return time_;
    }

    bool
    isInitial() const
    {
        return proposeSeq_ == kSeqJoin;
    }

    bool
    isBowOut() const
    {
        return proposeSeq_ == kSeqLeave;
    }

    bool
    isStale(NetClock::time_point cutoff) const
    {
        return time_ <= cutoff;
    }

    void
    changePosition(
        Position const& newPosition,
        NetClock::time_point newCloseTime,
        NetClock::time_point now)
    {
        signingHash_.reset();
        position_ = newPosition;
        closeTime_ = newCloseTime;
        time_ = now;
        if (proposeSeq_ != kSeqLeave)
            ++proposeSeq_;
    }

    void
    bowOut(NetClock::time_point now)
    {
        signingHash_.reset();
        time_ = now;
        proposeSeq_ = kSeqLeave;
    }
 
    std::string
    render() const
    {
        std::stringstream ss;
        ss << "proposal: previous_ledger: " << previousLedger_ << " proposal_seq: " << proposeSeq_
           << " position: " << position_ << " close_time: " << to_string(closeTime_)
           << " now: " << to_string(time_) << " is_bow_out:" << isBowOut()
           << " node_id: " << nodeID_;
        return ss.str();
    }

    json::Value
    getJson() const
    {
        using std::to_string;
 
        json::Value ret = json::ValueType::Object;
        ret[jss::previous_ledger] = to_string(prevLedger());
 
        if (!isBowOut())
        {
            ret[jss::transaction_hash] = to_string(position());
            ret[jss::propose_seq] = proposeSeq();
        }
 
        ret[jss::close_time] = to_string(closeTime().time_since_epoch().count());
 
        return ret;
    }

    uint256 const&
    signingHash() const
    {
        if (!signingHash_)
        {
            signingHash_ = sha512Half(
                HashPrefix::Proposal,
                std::uint32_t(proposeSeq()),
                closeTime().time_since_epoch().count(),
                prevLedger(),
                position());
        }
 
        return signingHash_.value();
    }
 
private:
    LedgerId previousLedger_;

    Position position_;

    NetClock::time_point closeTime_;
 
    // !The time this position was last updated
    NetClock::time_point time_;

    std::uint32_t proposeSeq_;

    NodeId nodeID_;

    mutable std::optional<uint256> signingHash_;
};
 
template <class NodeId, class LedgerId, class Position>
bool
operator==(
    ConsensusProposal<NodeId, LedgerId, Position> const& a,
    ConsensusProposal<NodeId, LedgerId, Position> const& b)
{
    return a.nodeID() == b.nodeID() && a.proposeSeq() == b.proposeSeq() &&
        a.prevLedger() == b.prevLedger() && a.position() == b.position() &&
        a.closeTime() == b.closeTime() && a.seenTime() == b.seenTime();
}
}  // namespace xrpl