ConsensusProposal.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012-2017 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVID_tED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_CONSENSUS_CONSENSUSPROPOSAL_H_INCLUDED
#define RIPPLE_CONSENSUS_CONSENSUSPROPOSAL_H_INCLUDED
 
#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>
 
namespace ripple {
template <class NodeID_t, class LedgerID_t, class Position_t>
class ConsensusProposal
{
public:
    using NodeID = NodeID_t;
 
    //< Sequence value when a peer initially joins consensus
    static std::uint32_t const seqJoin = 0;
 
    //< Sequence number when  a peer wants to bow out and leave consensus
    static std::uint32_t const seqLeave = 0xffffffff;
 
    ConsensusProposal(
        LedgerID_t const& prevLedger,
        std::uint32_t seq,
        Position_t const& position,
        NetClock::time_point closeTime,
        NetClock::time_point now,
        NodeID_t const& nodeID)
        : previousLedger_(prevLedger)
        , position_(position)
        , closeTime_(closeTime)
        , time_(now)
        , proposeSeq_(seq)
        , nodeID_(nodeID)
    {
    }
 
    NodeID_t const&
    nodeID() const
    {
        return nodeID_;
    }
 
    Position_t const&
    position() const
    {
        return position_;
    }
 
    LedgerID_t 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_ == seqJoin;
    }
 
    bool
    isBowOut() const
    {
        return proposeSeq_ == seqLeave;
    }
 
    bool
    isStale(NetClock::time_point cutoff) const
    {
        return time_ <= cutoff;
    }
 
    void
    changePosition(
        Position_t const& newPosition,
        NetClock::time_point newCloseTime,
        NetClock::time_point now)
    {
        signingHash_.reset();
        position_ = newPosition;
        closeTime_ = newCloseTime;
        time_ = now;
        if (proposeSeq_ != seqLeave)
            ++proposeSeq_;
    }
 
    void
    bowOut(NetClock::time_point now)
    {
        signingHash_.reset();
        time_ = now;
        proposeSeq_ = seqLeave;
    }
 
    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::objectValue;
        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_t previousLedger_;
 
    Position_t position_;
 
    NetClock::time_point closeTime_;
 
    // !The time this position was last updated
    NetClock::time_point time_;
 
    std::uint32_t proposeSeq_;
 
    NodeID_t nodeID_;
 
    mutable std::optional<uint256> signingHash_;
};
 
template <class NodeID_t, class LedgerID_t, class Position_t>
bool
operator==(
    ConsensusProposal<NodeID_t, LedgerID_t, Position_t> const& a,
    ConsensusProposal<NodeID_t, LedgerID_t, Position_t> 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 ripple
#endif