applySteps.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/OpenView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/SeqProxy.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxMeta.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <cstdint>
#include <expected>
#include <optional>
#include <utility>
 
namespace xrpl {
 
class ServiceRegistry;
class STTx;
class TxQ;
 
struct ApplyResult
{
    TER ter;
    bool applied;
    std::optional<TxMeta> metadata;
 
    ApplyResult(TER t, bool a, std::optional<TxMeta> m = std::nullopt)
        : ter(t), applied(a), metadata(std::move(m))
    {
    }
};

inline bool
isTecClaimHardFail(TER ter, ApplyFlags flags)
{
    return isTecClaim(ter) && ((flags & TapRetry) == 0u);
}

class TxConsequences
{
public:
    enum class Category {
        Normal = 0,
        Blocker
    };
 
private:
    bool isBlocker_;
    XRPAmount fee_;
    XRPAmount potentialSpend_;
    SeqProxy seqProx_;
    std::uint32_t sequencesConsumed_;
 
public:
    // Constructor if preflight returns a value other than tesSUCCESS.
    // Asserts if tesSUCCESS is passed.
    explicit TxConsequences(NotTEC pfResult);

    explicit TxConsequences(STTx const& tx);

    TxConsequences(STTx const& tx, Category category);

    TxConsequences(STTx const& tx, XRPAmount potentialSpend);

    TxConsequences(STTx const& tx, std::uint32_t sequencesConsumed);

    TxConsequences(TxConsequences const&) = default;
    TxConsequences&
    operator=(TxConsequences const&) = default;
    TxConsequences(TxConsequences&&) = default;
    TxConsequences&
    operator=(TxConsequences&&) = default;

    [[nodiscard]] XRPAmount
    fee() const
    {
        return fee_;
    }

    [[nodiscard]] XRPAmount const&
    potentialSpend() const
    {
        return potentialSpend_;
    }

    [[nodiscard]] SeqProxy
    seqProxy() const
    {
        return seqProx_;
    }

    [[nodiscard]] std::uint32_t
    sequencesConsumed() const
    {
        return sequencesConsumed_;
    }

    [[nodiscard]] bool
    isBlocker() const
    {
        return isBlocker_;
    }
 
    // Return the SeqProxy that would follow this.
    [[nodiscard]] SeqProxy
    followingSeq() const
    {
        SeqProxy following = seqProx_;
        following.advanceBy(sequencesConsumed());
        return following;
    }
};

struct PreflightResult
{
public:
    STTx const& tx;
    std::optional<UInt256 const> const parentBatchId;
    Rules const rules;
    TxConsequences const consequences;
    ApplyFlags const flags;
    beast::Journal const j;

    NotTEC const ter;

    template <class Context>
    PreflightResult(Context const& ctx, std::pair<NotTEC, TxConsequences> const& result)
        : tx(ctx.tx)
        , parentBatchId(ctx.parentBatchId)
        , rules(ctx.rules)
        , consequences(result.second)
        , flags(ctx.flags)
        , j(ctx.j)
        , ter(result.first)
    {
    }
 
    PreflightResult(PreflightResult const&) = default;
    PreflightResult&
    operator=(PreflightResult const&) = delete;
};

struct PreclaimResult
{
public:
    ReadView const& view;
    STTx const& tx;
    std::optional<UInt256 const> const parentBatchId;
    ApplyFlags const flags;
    beast::Journal const j;

    TER const ter;

    bool const likelyToClaimFee{};

    template <class Context>
    PreclaimResult(Context const& ctx, TER ter)
        : view(ctx.view)
        , tx(ctx.tx)
        , parentBatchId(ctx.parentBatchId)
        , flags(ctx.flags)
        , j(ctx.j)
        , ter(ter)
        , likelyToClaimFee(isTesSuccess(ter) || isTecClaimHardFail(ter, flags))
    {
    }
 
    PreclaimResult(PreclaimResult const&) = default;
    PreclaimResult&
    operator=(PreclaimResult const&) = delete;
};

PreflightResult
preflight(
    ServiceRegistry& registry,
    Rules const& rules,
    STTx const& tx,
    ApplyFlags flags,
    beast::Journal j);
 
PreflightResult
preflight(
    ServiceRegistry& registry,
    Rules const& rules,
    UInt256 const& parentBatchId,
    STTx const& tx,
    ApplyFlags flags,
    beast::Journal j);

PreclaimResult
preclaim(PreflightResult const& preflightResult, ServiceRegistry& registry, OpenView const& view);

NotTEC
invokeCheckPermission(ReadView const& view, STTx const& tx);

[[nodiscard]] std::expected<XRPAmount, TER>
calculateBaseFee(ReadView const& view, STTx const& tx);

XRPAmount
calculateDefaultBaseFee(ReadView const& view, STTx const& tx);

ApplyResult
doApply(PreclaimResult const& preclaimResult, ServiceRegistry& registry, OpenView& view);
 
}  // namespace xrpl