Transactor.h

#pragma once
 
#include <xrpld/app/tx/applySteps.h>
#include <xrpld/app/tx/detail/ApplyContext.h>
 
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/WrappedSink.h>
#include <xrpl/protocol/Permissions.h>
#include <xrpl/protocol/XRPAmount.h>
 
namespace xrpl {
 
struct PreflightContext
{
public:
    Application& app;
    STTx const& tx;
    Rules const rules;
    ApplyFlags flags;
    std::optional<uint256 const> parentBatchId;
    beast::Journal const j;
 
    PreflightContext(
        Application& app_,
        STTx const& tx_,
        uint256 parentBatchId_,
        Rules const& rules_,
        ApplyFlags flags_,
        beast::Journal j_ = beast::Journal{beast::Journal::getNullSink()})
        : app(app_), tx(tx_), rules(rules_), flags(flags_), parentBatchId(parentBatchId_), j(j_)
    {
        XRPL_ASSERT((flags_ & tapBATCH) == tapBATCH, "Batch apply flag should be set");
    }
 
    PreflightContext(
        Application& app_,
        STTx const& tx_,
        Rules const& rules_,
        ApplyFlags flags_,
        beast::Journal j_ = beast::Journal{beast::Journal::getNullSink()})
        : app(app_), tx(tx_), rules(rules_), flags(flags_), j(j_)
    {
        XRPL_ASSERT((flags_ & tapBATCH) == 0, "Batch apply flag should not be set");
    }
 
    PreflightContext&
    operator=(PreflightContext const&) = delete;
};
 
struct PreclaimContext
{
public:
    Application& app;
    ReadView const& view;
    TER preflightResult;
    ApplyFlags flags;
    STTx const& tx;
    std::optional<uint256 const> const parentBatchId;
    beast::Journal const j;
 
    PreclaimContext(
        Application& app_,
        ReadView const& view_,
        TER preflightResult_,
        STTx const& tx_,
        ApplyFlags flags_,
        std::optional<uint256> parentBatchId_,
        beast::Journal j_ = beast::Journal{beast::Journal::getNullSink()})
        : app(app_)
        , view(view_)
        , preflightResult(preflightResult_)
        , flags(flags_)
        , tx(tx_)
        , parentBatchId(parentBatchId_)
        , j(j_)
    {
        XRPL_ASSERT(
            parentBatchId.has_value() == ((flags_ & tapBATCH) == tapBATCH),
            "Parent Batch ID should be set if batch apply flag is set");
    }
 
    PreclaimContext(
        Application& app_,
        ReadView const& view_,
        TER preflightResult_,
        STTx const& tx_,
        ApplyFlags flags_,
        beast::Journal j_ = beast::Journal{beast::Journal::getNullSink()})
        : PreclaimContext(app_, view_, preflightResult_, tx_, flags_, std::nullopt, j_)
    {
        XRPL_ASSERT((flags_ & tapBATCH) == 0, "Batch apply flag should not be set");
    }
 
    PreclaimContext&
    operator=(PreclaimContext const&) = delete;
};
 
class TxConsequences;
struct PreflightResult;
// Needed for preflight specialization
class Change;
 
class Transactor
{
protected:
    ApplyContext& ctx_;
    beast::WrappedSink sink_;
    beast::Journal const j_;
 
    AccountID const account_;
    XRPAmount mPriorBalance;   // Balance before fees.
    XRPAmount mSourceBalance;  // Balance after fees.
 
    virtual ~Transactor() = default;
    Transactor(Transactor const&) = delete;
    Transactor&
    operator=(Transactor const&) = delete;
 
public:
    enum ConsequencesFactoryType { Normal, Blocker, Custom };
    ApplyResult
    operator()();
 
    ApplyView&
    view()
    {
        return ctx_.view();
    }
 
    ApplyView const&
    view() const
    {
        return ctx_.view();
    }
 
    /*
    These static functions are called from invoke_preclaim<Tx>
    using name hiding to accomplish compile-time polymorphism,
    so derived classes can override for different or extra
    functionality. Use with care, as these are not really
    virtual and so don't have the compiler-time protection that
    comes with it.
    */
 
    static NotTEC
    checkSeqProxy(ReadView const& view, STTx const& tx, beast::Journal j);
 
    static NotTEC
    checkPriorTxAndLastLedger(PreclaimContext const& ctx);
 
    static TER
    checkFee(PreclaimContext const& ctx, XRPAmount baseFee);
 
    static NotTEC
    checkSign(PreclaimContext const& ctx);
 
    static NotTEC
    checkBatchSign(PreclaimContext const& ctx);
 
    // Returns the fee in fee units, not scaled for load.
    static XRPAmount
    calculateBaseFee(ReadView const& view, STTx const& tx);
 
    /* Do NOT define an invokePreflight function in a derived class.
       Instead, define:
 
        // Optional if the transaction is gated on an amendment that
        // isn't specified in transactions.macro
        static bool
        checkExtraFeatures(PreflightContext const& ctx);
 
        // Optional if the transaction uses any flags other than tfUniversal
        static std::uint32_t
        getFlagsMask(PreflightContext const& ctx);
 
        // Required, even if it just returns tesSUCCESS.
        static NotTEC
        preflight(PreflightContext const& ctx);
 
        // Optional, rarely needed, if the transaction does any expensive
        // checks after the signature is verified.
        static NotTEC preflightSigValidated(PreflightContext const& ctx);
 
       * Do not try to call preflight1 or preflight2 directly.
       * Do not check whether relevant amendments are enabled in preflight.
         Instead, define checkExtraFeatures.
       * Do not check flags in preflight. Instead, define getFlagsMask.
    */
    template <class T>
    static NotTEC
    invokePreflight(PreflightContext const& ctx);
 
    static TER
    preclaim(PreclaimContext const& ctx)
    {
        // Most transactors do nothing
        // after checkSeq/Fee/Sign.
        return tesSUCCESS;
    }
 
    static NotTEC
    checkPermission(ReadView const& view, STTx const& tx);
 
    // Interface used by DeleteAccount
    static TER
    ticketDelete(ApplyView& view, AccountID const& account, uint256 const& ticketIndex, beast::Journal j);
 
protected:
    TER
    apply();
 
    explicit Transactor(ApplyContext& ctx);
 
    virtual void
    preCompute();
 
    virtual TER
    doApply() = 0;
 
    static XRPAmount
    minimumFee(Application& app, XRPAmount baseFee, Fees const& fees, ApplyFlags flags);
 
    // Returns the fee in fee units, not scaled for load.
    static XRPAmount
    calculateOwnerReserveFee(ReadView const& view, STTx const& tx);
 
    static NotTEC
    checkSign(
        ReadView const& view,
        ApplyFlags flags,
        std::optional<uint256 const> const& parentBatchId,
        AccountID const& idAccount,
        STObject const& sigObject,
        beast::Journal const j);
 
    // Base class always returns true
    static bool
    checkExtraFeatures(PreflightContext const& ctx);
 
    // Base class always returns tfUniversalMask
    static std::uint32_t
    getFlagsMask(PreflightContext const& ctx);
 
    // Base class always returns tesSUCCESS
    static NotTEC
    preflightSigValidated(PreflightContext const& ctx);
 
    static bool
    validDataLength(std::optional<Slice> const& slice, std::size_t maxLength);
 
    template <class T>
    static bool
    validNumericRange(std::optional<T> value, T max, T min = T{});
 
    template <class T, class Unit>
    static bool
    validNumericRange(
        std::optional<T> value,
        unit::ValueUnit<Unit, T> max,
        unit::ValueUnit<Unit, T> min = unit::ValueUnit<Unit, T>{});
 
    template <class T>
    static bool
    validNumericMinimum(std::optional<T> value, T min = T{});
 
    template <class T, class Unit>
    static bool
    validNumericMinimum(std::optional<T> value, unit::ValueUnit<Unit, T> min = unit::ValueUnit<Unit, T>{});
 
private:
    std::pair<TER, XRPAmount>
    reset(XRPAmount fee);
 
    TER
    consumeSeqProxy(SLE::pointer const& sleAccount);
    TER
    payFee();
    static NotTEC
    checkSingleSign(
        ReadView const& view,
        AccountID const& idSigner,
        AccountID const& idAccount,
        std::shared_ptr<SLE const> sleAccount,
        beast::Journal const j);
    static NotTEC
    checkMultiSign(
        ReadView const& view,
        ApplyFlags flags,
        AccountID const& id,
        STObject const& sigObject,
        beast::Journal const j);
 
    void trapTransaction(uint256) const;
 
    static NotTEC
    preflight1(PreflightContext const& ctx, std::uint32_t flagMask);
 
    static NotTEC
    preflight2(PreflightContext const& ctx);
};
 
inline bool
Transactor::checkExtraFeatures(PreflightContext const& ctx)
{
    return true;
}
 
NotTEC
preflight0(PreflightContext const& ctx, std::uint32_t flagMask);
 
namespace detail {
 
NotTEC
preflightCheckSigningKey(STObject const& sigObject, beast::Journal j);
 
std::optional<NotTEC>
preflightCheckSimulateKeys(ApplyFlags flags, STObject const& sigObject, beast::Journal j);
}  // namespace detail
 
// Defined in Change.cpp
template <>
NotTEC
Transactor::invokePreflight<Change>(PreflightContext const& ctx);
 
template <class T>
NotTEC
Transactor::invokePreflight(PreflightContext const& ctx)
{
    // Using this lookup does NOT require checking the fixDelegateV1_1. The data
    // exists regardless of whether it is enabled.
    auto const feature = Permission::getInstance().getTxFeature(ctx.tx.getTxnType());
 
    if (feature && !ctx.rules.enabled(*feature))
        return temDISABLED;
 
    if (!T::checkExtraFeatures(ctx))
        return temDISABLED;
 
    if (auto const ret = preflight1(ctx, T::getFlagsMask(ctx)))
        return ret;
 
    if (auto const ret = T::preflight(ctx))
        return ret;
 
    if (auto const ret = preflight2(ctx))
        return ret;
 
    return T::preflightSigValidated(ctx);
}
 
template <class T>
bool
Transactor::validNumericRange(std::optional<T> value, T max, T min)
{
    if (!value)
        return true;
    return value >= min && value <= max;
}
 
template <class T, class Unit>
bool
Transactor::validNumericRange(std::optional<T> value, unit::ValueUnit<Unit, T> max, unit::ValueUnit<Unit, T> min)
{
    return validNumericRange(value, max.value(), min.value());
}
 
template <class T>
bool
Transactor::validNumericMinimum(std::optional<T> value, T min)
{
    if (!value)
        return true;
    return value >= min;
}
 
template <class T, class Unit>
bool
Transactor::validNumericMinimum(std::optional<T> value, unit::ValueUnit<Unit, T> min)
{
    return validNumericMinimum(value, min.value());
}
 
}  // namespace xrpl