LoadFeeTrack.h

#pragma once
 
#include <xrpl/basics/Log.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <algorithm>
#include <cstdint>
#include <mutex>
 
namespace xrpl {
 
struct Fees;
 
class LoadFeeTrack final
{
public:
    explicit LoadFeeTrack(beast::Journal journal = beast::Journal(beast::Journal::getNullSink()))
        : j_(journal)
        , localTxnLoadFee_(lftNormalFee)
        , remoteTxnLoadFee_(lftNormalFee)
        , clusterTxnLoadFee_(lftNormalFee)
        , raiseCount_(0)
    {
    }
 
    ~LoadFeeTrack() = default;
 
    void
    setRemoteFee(std::uint32_t f)
    {
        JLOG(j_.trace()) << "setRemoteFee: " << f;
        std::lock_guard sl(lock_);
        remoteTxnLoadFee_ = f;
    }
 
    std::uint32_t
    getRemoteFee() const
    {
        std::lock_guard sl(lock_);
        return remoteTxnLoadFee_;
    }
 
    std::uint32_t
    getLocalFee() const
    {
        std::lock_guard sl(lock_);
        return localTxnLoadFee_;
    }
 
    std::uint32_t
    getClusterFee() const
    {
        std::lock_guard sl(lock_);
        return clusterTxnLoadFee_;
    }
 
    std::uint32_t
    getLoadBase() const
    {
        return lftNormalFee;
    }
 
    std::uint32_t
    getLoadFactor() const
    {
        std::lock_guard sl(lock_);
        return std::max({clusterTxnLoadFee_, localTxnLoadFee_, remoteTxnLoadFee_});
    }
 
    std::pair<std::uint32_t, std::uint32_t>
    getScalingFactors() const
    {
        std::lock_guard sl(lock_);
 
        return std::make_pair(
            std::max(localTxnLoadFee_, remoteTxnLoadFee_), std::max(remoteTxnLoadFee_, clusterTxnLoadFee_));
    }
 
    void
    setClusterFee(std::uint32_t fee)
    {
        JLOG(j_.trace()) << "setClusterFee: " << fee;
        std::lock_guard sl(lock_);
        clusterTxnLoadFee_ = fee;
    }
 
    bool
    raiseLocalFee();
    bool
    lowerLocalFee();
 
    bool
    isLoadedLocal() const
    {
        std::lock_guard sl(lock_);
        return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee);
    }
 
    bool
    isLoadedCluster() const
    {
        std::lock_guard sl(lock_);
        return (raiseCount_ != 0) || (localTxnLoadFee_ != lftNormalFee) || (clusterTxnLoadFee_ != lftNormalFee);
    }
 
private:
    static std::uint32_t constexpr lftNormalFee = 256;     // 256 is the minimum/normal load factor
    static std::uint32_t constexpr lftFeeIncFraction = 4;  // increase fee by 1/4
    static std::uint32_t constexpr lftFeeDecFraction = 4;  // decrease fee by 1/4
    static std::uint32_t constexpr lftFeeMax = lftNormalFee * 1000000;
 
    beast::Journal const j_;
    std::mutex mutable lock_;
 
    std::uint32_t localTxnLoadFee_;    // Scale factor, lftNormalFee = normal fee
    std::uint32_t remoteTxnLoadFee_;   // Scale factor, lftNormalFee = normal fee
    std::uint32_t clusterTxnLoadFee_;  // Scale factor, lftNormalFee = normal fee
    std::uint32_t raiseCount_;
};
 
//------------------------------------------------------------------------------
 
// Scale using load as well as base rate
XRPAmount
scaleFeeLoad(XRPAmount fee, LoadFeeTrack const& feeTrack, Fees const& fees, bool bUnlimited);
 
}  // namespace xrpl