applySteps.h

#pragma once
 
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyViewImpl.h>
 
namespace xrpl {
 
class Application;
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);
}
 
class TxConsequences
{
public:
    enum 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;
 
    XRPAmount
    fee() const
    {
        return fee_;
    }
 
    XRPAmount const&
    potentialSpend() const
    {
        return potentialSpend_;
    }
 
    SeqProxy
    seqProxy() const
    {
        return seqProx_;
    }
 
    std::uint32_t
    sequencesConsumed() const
    {
        return sequencesConsumed_;
    }
 
    bool
    isBlocker() const
    {
        return isBlocker_;
    }
 
    // Return the SeqProxy that would follow this.
    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(ter == tesSUCCESS || isTecClaimHardFail(ter, flags))
    {
    }
 
    PreclaimResult(PreclaimResult const&) = default;
    PreclaimResult&
    operator=(PreclaimResult const&) = delete;
};
 
PreflightResult
preflight(Application& app, Rules const& rules, STTx const& tx, ApplyFlags flags, beast::Journal j);
 
PreflightResult
preflight(
    Application& app,
    Rules const& rules,
    uint256 const& parentBatchId,
    STTx const& tx,
    ApplyFlags flags,
    beast::Journal j);
PreclaimResult
preclaim(PreflightResult const& preflightResult, Application& app, OpenView const& view);
 
XRPAmount
calculateBaseFee(ReadView const& view, STTx const& tx);
 
XRPAmount
calculateDefaultBaseFee(ReadView const& view, STTx const& tx);
 
ApplyResult
doApply(PreclaimResult const& preclaimResult, Application& app, OpenView& view);
 
}  // namespace xrpl