DisputedTx.h

#pragma once
 
#include <xrpl/basics/Log.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/consensus/ConsensusParms.h>
#include <xrpl/json/json_value.h>
#include <xrpl/json/json_writer.h>
 
#include <boost/container/flat_map.hpp>
 
#include <cstddef>
#include <memory>
#include <sstream>
#include <string>
#include <utility>
 
namespace xrpl {

 
template <class Tx, class NodeId>
class DisputedTx
{
    using TxID_t = Tx::ID;
    using Map_t = boost::container::flat_map<NodeId, bool>;
 
public:
    DisputedTx(Tx tx, bool ourVote, std::size_t numPeers, beast::Journal j)
        : ourVote_(ourVote), tx_(std::move(tx)), j_(j)
    {
        votes_.reserve(numPeers);
    }

    [[nodiscard]] TxID_t const&
    id() const
    {
        return tx_.id();
    }

    [[nodiscard]] bool
    getOurVote() const
    {
        return ourVote_;
    }

    [[nodiscard]] bool
    stalled(
        ConsensusParms const& p,
        bool proposing,
        int peersUnchanged,
        beast::Journal j,
        std::unique_ptr<std::stringstream> const& clog) const
    {
        // at() can throw, but the map is built by hand to ensure all valid
        // values are available.
        auto const& currentCutoff = p.avalancheCutoffs.at(avalancheState_);
        auto const& nextCutoff = p.avalancheCutoffs.at(currentCutoff.next);
 
        // We're have not reached the final avalanche state, or been there long
        // enough, so there's room for change. Check the times in case the state
        // machine is altered to allow states to loop.
        if (nextCutoff.consensusTime > currentCutoff.consensusTime ||
            avalancheCounter_ < p.avMinRounds)
            return false;
 
        // We've haven't had this vote for minimum rounds yet. Things could
        // change.
        if (proposing && currentVoteCounter_ < p.avMinRounds)
            return false;
 
        // If we or any peers have changed a vote in several rounds, then
        // things could still change. But if _either_ has not changed in that
        // long, we're unlikely to change our vote any time soon. (This prevents
        // a malicious peer from flip-flopping a vote to prevent consensus.)
        if (peersUnchanged < p.avStalledRounds &&
            (proposing && currentVoteCounter_ < p.avStalledRounds))
            return false;
 
        // Does this transaction have more than 80% agreement
 
        // Compute the percentage of nodes voting 'yes' (possibly including us)
        int const support = (yays_ + (proposing && ourVote_ ? 1 : 0)) * 100;
        int const total = nays_ + yays_ + (proposing ? 1 : 0);
        if (total == 0)
        {
            // There are no votes, so we know nothing
            return false;
        }
        int const weight = support / total;
        // Returns true if the tx has more than minCONSENSUS_PCT (80) percent
        // agreement. Either voting for _or_ voting against the tx.
        bool const stalled = weight > p.minConsensusPct || weight < (100 - p.minConsensusPct);
 
        if (stalled)
        {
            // stalling is an error condition for even a single
            // transaction.
            std::stringstream s;
            s << "Transaction " << id() << " is stalled. We have been voting "
              << (getOurVote() ? "YES" : "NO") << " for " << currentVoteCounter_
              << " rounds. Peers have not changed their votes in " << peersUnchanged
              << " rounds. The transaction has " << weight << "% support. ";
            JLOG(j_.error()) << s.str();
            CLOG(clog) << s.str();
        }
 
        return stalled;
    }

    [[nodiscard]] Tx const&
    tx() const
    {
        return tx_;
    }

    void
    setOurVote(bool o)
    {
        ourVote_ = o;
    }

    [[nodiscard]] bool
    setVote(NodeId const& peer, bool votesYes);

    void
    unVote(NodeId const& peer);

    bool
    updateVote(int percentTime, bool proposing, ConsensusParms const& p);

    [[nodiscard]] json::Value
    getJson() const;
 
private:
    int yays_{0};   //< Number of yes votes
    int nays_{0};   //< Number of no votes
    bool ourVote_;  //< Our vote (true is yes)
    Tx tx_;         //< Transaction under dispute
    Map_t votes_;   //< Map from NodeID to vote
    std::size_t currentVoteCounter_ = 0;
    ConsensusParms::AvalancheState avalancheState_ = ConsensusParms::AvalancheState::Init;
    std::size_t avalancheCounter_ = 0;
    beast::Journal const j_;
};
 
// Track a peer's yes/no vote on a particular disputed tx_
template <class Tx, class NodeId>
bool
DisputedTx<Tx, NodeId>::setVote(NodeId const& peer, bool votesYes)
{
    auto const [it, inserted] = votes_.insert(std::make_pair(peer, votesYes));
 
    // new vote
    if (inserted)
    {
        if (votesYes)
        {
            JLOG(j_.debug()) << "Peer " << peer << " votes YES on " << tx_.id();
            ++yays_;
        }
        else
        {
            JLOG(j_.debug()) << "Peer " << peer << " votes NO on " << tx_.id();
            ++nays_;
        }
        return true;
    }
    // changes vote to yes
    if (votesYes && !it->second)
    {
        JLOG(j_.debug()) << "Peer " << peer << " now votes YES on " << tx_.id();
        --nays_;
        ++yays_;
        it->second = true;
        return true;
    }
    // changes vote to no
    if (!votesYes && it->second)
    {
        JLOG(j_.debug()) << "Peer " << peer << " now votes NO on " << tx_.id();
        ++nays_;
        --yays_;
        it->second = false;
        return true;
    }
    return false;
}
 
// Remove a peer's vote on this disputed transaction
template <class Tx, class NodeId>
void
DisputedTx<Tx, NodeId>::unVote(NodeId const& peer)
{
    auto it = votes_.find(peer);
 
    if (it != votes_.end())
    {
        if (it->second)
        {
            --yays_;
        }
        else
        {
            --nays_;
        }
 
        votes_.erase(it);
    }
}
 
template <class Tx, class NodeId>
bool
DisputedTx<Tx, NodeId>::updateVote(int percentTime, bool proposing, ConsensusParms const& p)
{
    if (ourVote_ && (nays_ == 0))
        return false;
 
    if (!ourVote_ && (yays_ == 0))
        return false;
 
    bool newPosition = false;
    int weight = 0;
 
    // When proposing, to prevent avalanche stalls, we increase the needed
    // weight slightly over time. We also need to ensure that the consensus has
    // made a minimum number of attempts at each "state" before moving
    // to the next.
    // Proposing or not, we need to keep track of which state we've reached so
    // we can determine if the vote has stalled.
    auto const [requiredPct, newState] =
        getNeededWeight(p, avalancheState_, percentTime, ++avalancheCounter_, p.avMinRounds);
    if (newState)
    {
        avalancheState_ = *newState;
        avalancheCounter_ = 0;
    }
 
    if (proposing)  // give ourselves full weight
    {
        // This is basically the percentage of nodes voting 'yes' (including us)
        weight = ((yays_ * 100) + (ourVote_ ? 100 : 0)) / (nays_ + yays_ + 1);
 
        newPosition = weight > requiredPct;
    }
    else
    {
        // don't let us outweigh a proposing node, just recognize consensus
        weight = -1;
        newPosition = yays_ > nays_;
    }
 
    if (newPosition == ourVote_)
    {
        ++currentVoteCounter_;
        JLOG(j_.info()) << "No change (" << (ourVote_ ? "YES" : "NO") << ") on " << tx_.id()
                        << " : weight " << weight << ", percent " << percentTime
                        << ", round(s) with this vote: " << currentVoteCounter_;
        JLOG(j_.debug()) << json::Compact{getJson()};
        return false;
    }
 
    currentVoteCounter_ = 0;
    ourVote_ = newPosition;
    JLOG(j_.debug()) << "We now vote " << (ourVote_ ? "YES" : "NO") << " on " << tx_.id();
    JLOG(j_.debug()) << json::Compact{getJson()};
    return true;
}
 
template <class Tx, class NodeId>
json::Value
DisputedTx<Tx, NodeId>::getJson() const
{
    using std::to_string;
 
    json::Value ret(json::ValueType::Object);
 
    ret["yays"] = yays_;
    ret["nays"] = nays_;
    ret["our_vote"] = ourVote_;
 
    if (!votes_.empty())
    {
        json::Value votes(json::ValueType::Object);
        for (auto const& [nodeId, vote] : votes_)
            votes[to_string(nodeId)] = vote;
        ret["votes"] = std::move(votes);
    }
 
    return ret;
}
 
}  // namespace xrpl