TxTest.h

#pragma once
 
#include <xrpl/basics/Number.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/hash/uhash.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/ledger/Ledger.h>
#include <xrpl/ledger/OpenView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/Rules.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/TxMeta.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/protocol_autogen/TransactionBuilderBase.h>
#include <xrpl/protocol_autogen/ledger_entries/AccountRoot.h>
#include <xrpl/tx/applySteps.h>
 
#include <helpers/Account.h>
#include <helpers/IOU.h>
#include <helpers/TestServiceRegistry.h>
 
#include <cmath>
#include <concepts>
#include <cstdint>
#include <memory>
#include <optional>
#include <stdexcept>
#include <type_traits>
#include <unordered_set>
#include <vector>
 
namespace xrpl::test {
 
//------------------------------------------------------------------------------
// Amount helpers
//------------------------------------------------------------------------------

template <std::integral T>
constexpr XRPAmount
XRP(T xrp)  // NOLINT(readability-identifier-naming)
{
    return XRPAmount{static_cast<std::int64_t>(xrp) * kDropsPerXrp.drops()};
}

template <std::floating_point T>
XRPAmount
XRP(T xrp)
{
    return XRPAmount{static_cast<std::int64_t>(std::round(xrp * kDropsPerXrp.drops()))};
}

inline XRPAmount
XRP(Number const& xrp)
{
    return XRPAmount{static_cast<std::int64_t>(xrp * kDropsPerXrp.drops())};
}
 
//------------------------------------------------------------------------------
// Flag helpers
//------------------------------------------------------------------------------

constexpr std::uint32_t
asfToLsf(std::uint32_t asf)
{
    switch (asf)
    {
        case asfRequireDest:
            return lsfRequireDestTag;
        case asfRequireAuth:
            return lsfRequireAuth;
        case asfDisallowXRP:
            return lsfDisallowXRP;
        case asfDisableMaster:
            return lsfDisableMaster;
        case asfNoFreeze:
            return lsfNoFreeze;
        case asfGlobalFreeze:
            return lsfGlobalFreeze;
        case asfDefaultRipple:
            return lsfDefaultRipple;
        case asfDepositAuth:
            return lsfDepositAuth;
        case asfAllowTrustLineClawback:
            return lsfAllowTrustLineClawback;
        case asfDisallowIncomingCheck:
            return lsfDisallowIncomingCheck;
        case asfDisallowIncomingNFTokenOffer:
            return lsfDisallowIncomingNFTokenOffer;
        case asfDisallowIncomingPayChan:
            return lsfDisallowIncomingPayChan;
        case asfDisallowIncomingTrustline:
            return lsfDisallowIncomingTrustline;
        case asfAllowTrustLineLocking:
            return lsfAllowTrustLineLocking;
        default:
            throw std::runtime_error("Unknown asf flag");
    }
}
 
//------------------------------------------------------------------------------
// Feature helpers
//------------------------------------------------------------------------------

FeatureBitset
allFeatures();
 
//------------------------------------------------------------------------------
// TxResult
//------------------------------------------------------------------------------

struct TxResult
{
    TER ter;                         
    bool applied;                    
    std::optional<TxMeta> metadata;  
    std::shared_ptr<STTx const> tx;  
};

class TxTest
{
public:
    explicit TxTest(std::optional<FeatureBitset> features = std::nullopt);

    [[nodiscard]] bool
    isEnabled(uint256 const& feature) const;

    [[nodiscard]] Rules const&
    getRules() const;

    template <typename T>
        requires std::
            derived_from<std::decay_t<T>, transactions::TransactionBuilderBase<std::decay_t<T>>>
        [[nodiscard]] TxResult
        submit(T&& builder, Account const& signer)
    {
        auto const& obj = builder.getSTObject();
        auto accountId = obj[sfAccount];
        // Only set sequence if not using a ticket (ticket sets sequence to 0)
        if (!obj.isFieldPresent(sfTicketSequence))
        {
            builder.setSequence(getAccountRoot(accountId).getSequence());
        }
        else
        {
            builder.setSequence(0);
        }
        builder.setFee(XRPAmount(10));
        return submit(builder.build(signer.pk(), signer.sk()).getSTTx());
    }

    [[nodiscard]] TxResult
    submit(std::shared_ptr<STTx const> stx);

    void
    createAccount(Account const& account, XRPAmount xrp, uint32_t accountFlags = 0);

    [[nodiscard]] ledger_entries::AccountRoot
    getAccountRoot(AccountID const& id) const;

    [[nodiscard]] OpenView&
    getOpenLedger();

    [[nodiscard]] OpenView const&
    getOpenLedger() const;

    [[nodiscard]] ReadView const&
    getClosedLedger() const;

    void
    close();

    void
    advanceTime(NetClock::duration duration);

    [[nodiscard]] NetClock::time_point
    getCloseTime() const;

    [[nodiscard]] STAmount
    getBalance(AccountID const& account, IOU const& iou) const;

    ServiceRegistry&
    getServiceRegistry()
    {
        return registry_;
    }
 
private:
    TestServiceRegistry registry_;
    std::unordered_set<uint256, beast::Uhash<>> featureSet_;
    std::optional<Rules> rules_;
    std::shared_ptr<Ledger const> closedLedger_;
    std::shared_ptr<OpenView> openLedger_;

    std::vector<std::shared_ptr<STTx const>> pendingTxs_;

    NetClock::time_point now_;
};
 
}  // namespace xrpl::test