Env.h

#pragma once
 
#include <test/jtx/AbstractClient.h>
#include <test/jtx/Account.h>
#include <test/jtx/JTx.h>
#include <test/jtx/ManualTimeKeeper.h>
#include <test/jtx/amount.h>
#include <test/jtx/envconfig.h>
#include <test/jtx/require.h>
#include <test/jtx/vault.h>
#include <test/unit_test/SuiteJournal.h>
 
#include <xrpld/app/ledger/OpenLedger.h>
#include <xrpld/app/main/Application.h>
#include <xrpld/core/Config.h>
#include <xrpld/rpc/detail/Pathfinder.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/contract.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/json/json_value.h>
#include <xrpl/ledger/OpenView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/ApiVersion.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/Keylet.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
 
#include <array>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <future>
#include <initializer_list>
#include <memory>
#include <optional>
#include <source_location>
#include <stdexcept>
#include <string>
#include <thread>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace xrpl::test::jtx {

template <class T>
struct WithSourceLocation
{
    T value;
    std::source_location loc;
 
    // Non-explicit constructor allows implicit conversion.
    // The default argument for loc is evaluated at the call site.
    WithSourceLocation(T v, std::source_location l = std::source_location::current())
        : value(std::move(v)), loc(l)
    {
    }
};

template <class... Args>
std::array<Account, 1 + sizeof...(Args)>
noripple(Account const& account, Args const&... args)
{
    return {{account, args...}};
}
 
inline FeatureBitset
testableAmendments()
{
    static FeatureBitset const kIds = [] {
        auto const& sa = allAmendments();
        std::vector<uint256> feats;
        feats.reserve(sa.size());
        for (auto const& [s, vote] : sa)
        {
            (void)vote;
            if (auto const f = getRegisteredFeature(s))
            {
                feats.push_back(*f);
            }
            else
            {
                Throw<std::runtime_error>("Unknown feature: " + s + "  in allAmendments.");
            }
        }
        return FeatureBitset(feats);
    }();
    return kIds;
}

inline std::vector<FeatureBitset>
amendmentCombinations(std::initializer_list<uint256> features, FeatureBitset seed)
{
    std::vector<FeatureBitset> result{seed};
    for (auto const& f : features)
    {
        auto const n = result.size();
        for (std::size_t i = 0; i < n; ++i)
            result.push_back(result[i] - f);
    }
    return result;
}
 
//------------------------------------------------------------------------------
 
class SuiteLogs : public Logs
{
    beast::unit_test::Suite& suite_;
 
public:
    explicit SuiteLogs(beast::unit_test::Suite& suite) : Logs(beast::Severity::Error), suite_(suite)
    {
    }
 
    ~SuiteLogs() override = default;
 
    std::unique_ptr<beast::Journal::Sink>
    makeSink(std::string const& partition, beast::Severity threshold) override
    {
        return std::make_unique<SuiteJournalSink>(partition, threshold, suite_);
    }
};
 
//------------------------------------------------------------------------------

class Env
{
public:
    beast::unit_test::Suite& test;
 
    Account const& master = Account::kMaster;

    struct ParsedResult
    {
        std::optional<TER> ter;
        // RPC errors tend to return either a "code" and a "message" (sometimes
        // with an "error" that corresponds to the "code"), or with an "error"
        // and an "exception". However, this structure allows all possible
        // combinations.
        std::optional<ErrorCodeI> rpcCode;
        std::string rpcMessage;
        std::string rpcError;
        std::string rpcException;
    };
 
private:
    struct AppBundle
    {
        Application* app = nullptr;
        std::unique_ptr<Application> owned;
        ManualTimeKeeper* timeKeeper = nullptr;
        std::thread thread;
        std::unique_ptr<AbstractClient> client;
 
        AppBundle() = default;
        AppBundle(
            beast::unit_test::Suite& suite,
            std::unique_ptr<Config> config,
            std::unique_ptr<Logs> logs,
            beast::Severity thresh);
        ~AppBundle();
    };
 
    AppBundle bundle_;
 
public:
    beast::Journal const journal;
 
    Env() = delete;
    Env&
    operator=(Env const&) = delete;
    Env(Env const&) = delete;

    // VFALCO Could wrap the suite::log in a Journal here
    Env(beast::unit_test::Suite& suite,
        std::unique_ptr<Config> config,
        FeatureBitset features,
        std::unique_ptr<Logs> logs = nullptr,
        beast::Severity thresh = beast::Severity::Error)
        : test(suite)
        , bundle_(suite, std::move(config), std::move(logs), thresh)
        , journal{bundle_.app->getJournal("Env")}
    {
        memoize(Account::kMaster);
        Pathfinder::initPathTable();
        foreachFeature(features, [&appFeats = app().config().features](uint256 const& f) {
            appFeats.insert(f);
        });
    }

    Env(beast::unit_test::Suite& suite,
        FeatureBitset features,
        std::unique_ptr<Logs> logs = nullptr)
        : Env(suite, envconfig(), features, std::move(logs))
    {
    }

    Env(beast::unit_test::Suite& suite,
        std::unique_ptr<Config> config,
        std::unique_ptr<Logs> logs = nullptr,
        beast::Severity thresh = beast::Severity::Error)
        : Env(suite, std::move(config), testableAmendments(), std::move(logs), thresh)
    {
    }

    Env(beast::unit_test::Suite& suite, beast::Severity thresh = beast::Severity::Error)
        : Env(suite, envconfig(), nullptr, thresh)
    {
    }
 
    virtual ~Env() = default;
 
    Application&
    // NOLINTNEXTLINE(readability-make-member-function-const)
    app()
    {
        return *bundle_.app;
    }
 
    [[nodiscard]] Application const&
    app() const
    {
        return *bundle_.app;
    }
 
    ManualTimeKeeper&
    // NOLINTNEXTLINE(readability-make-member-function-const)
    timeKeeper()
    {
        return *bundle_.timeKeeper;
    }

    NetClock::time_point
    // NOLINTNEXTLINE(readability-make-member-function-const)
    now()
    {
        return timeKeeper().now();
    }

    AbstractClient&
    // NOLINTNEXTLINE(readability-make-member-function-const)
    client()
    {
        return *bundle_.client;
    }

    template <class... Args>
    json::Value
    rpc(unsigned apiVersion,
        std::unordered_map<std::string, std::string> const& headers,
        std::string const& cmd,
        Args&&... args);
 
    template <class... Args>
    json::Value
    rpc(unsigned apiVersion, std::string const& cmd, Args&&... args);
 
    template <class... Args>
    json::Value
    rpc(std::unordered_map<std::string, std::string> const& headers,
        std::string const& cmd,
        Args&&... args);
 
    template <class... Args>
    json::Value
    rpc(std::string const& cmd, Args&&... args);

    [[nodiscard]] std::shared_ptr<OpenView const>
    current() const
    {
        return app().getOpenLedger().current();
    }

    std::shared_ptr<ReadView const>
    closed();

    bool
    close(
        NetClock::time_point closeTime,
        std::optional<std::chrono::milliseconds> consensusDelay = std::nullopt);

    template <class Rep, class Period>
    bool
    close(std::chrono::duration<Rep, Period> const& elapsed)
    {
        // VFALCO Is this the correct time?
        return close(now() + elapsed);
    }

    bool
    close()
    {
        // VFALCO Is this the correct time?
        return close(std::chrono::seconds(5));
    }

    [[nodiscard]] bool
    syncClose(std::chrono::steady_clock::duration timeout = std::chrono::seconds{1})
    {
        XRPL_ASSERT(
            app().getNumberOfThreads() == 1,
            "syncClose() is only useful on an application with a single thread");
        auto const result = close();
        return result && drainServerIo(timeout);
    }

    [[nodiscard]] bool
    disconnectClient(std::chrono::steady_clock::duration timeout = std::chrono::seconds{1})
    {
        XRPL_ASSERT(
            app().getNumberOfThreads() == 1,
            "disconnectClient() is only useful on an application with a single "
            "thread");
 
        bundle_.client->disconnect();
 
        // Drain the server's single io thread twice: the first barrier flushes
        // the reactor's reap of the closed socket (queuing the peer teardown),
        // the second flushes that teardown - and therefore the connection-count
        // decrement. Both run unconditionally so a timed-out first drain does
        // not short-circuit the second.
        bool const reaped = drainServerIo(timeout);
        bool const toreDown = drainServerIo(timeout);
        return reaped && toreDown;
    }

    void
    trace(int howMany = -1)
    {
        trace_ = howMany;
    }

    void
    notrace()
    {
        trace_ = 0;
    }
 
    void
    setParseFailureExpected(bool b)
    {
        parseFailureExpected_ = b;
    }

    class ParseFailureGuard final
    {
        Env& self_;
        bool const oldExpected_;
 
    public:
        ParseFailureGuard(Env& self, bool b)
            : self_(self), oldExpected_(self_.parseFailureExpected_)
        {
            self_.setParseFailureExpected(b);
        }
 
        ~ParseFailureGuard()
        {
            self_.setParseFailureExpected(oldExpected_);
        }
 
        // No copy, no move
        ParseFailureGuard(ParseFailureGuard const&) = delete;
        ParseFailureGuard&
        operator=(ParseFailureGuard const&) = delete;
        ParseFailureGuard(ParseFailureGuard&& other) = delete;
        ParseFailureGuard&
        operator=(ParseFailureGuard&&) = delete;
    };

    [[nodiscard]] ParseFailureGuard
    getParseFailureGuard(bool b)
    {
        return ParseFailureGuard{*this, b};
    }

    void
    disableSigs()
    {
        app().checkSigs(false);
    }
 
    // set rpc retries
    void
    setRetries(unsigned r = 5)
    {
        retries_ = r;
    }
 
    // get rpc retries
    [[nodiscard]] unsigned
    retries() const
    {
        return retries_;
    }

    void
    memoize(Account const& account);

    [[nodiscard]] Account const&
    lookup(AccountID const& id) const;
 
    [[nodiscard]] Account const&
    lookup(std::string const& base58ID) const;

    [[nodiscard]] PrettyAmount
    balance(Account const& account) const;

    [[nodiscard]] std::uint32_t
    seq(Account const& account) const;

    // VFALCO NOTE This should return a unit-less amount
    [[nodiscard]] PrettyAmount
    balance(Account const& account, Asset const& asset) const;

    [[nodiscard]] PrettyAmount
    limit(Account const& account, Issue const& issue) const;

    [[nodiscard]] std::uint32_t
    ownerCount(Account const& account) const;

    [[nodiscard]] std::uint32_t
    sponsoredOwnerCount(Account const& account) const;

    [[nodiscard]] std::uint32_t
    sponsoringOwnerCount(Account const& account) const;

    [[nodiscard]] std::uint32_t
    sponsoringAccountCount(Account const& account) const;

    [[nodiscard]] SLE::const_pointer
    le(Account const& account) const;

    [[nodiscard]] SLE::const_pointer
    le(Keylet const& k) const;

    template <class JsonValue, class... FN>
    JTx
    jt(JsonValue&& jv, FN const&... fN)
    {
        JTx jt(std::forward<JsonValue>(jv));
        invoke(jt, fN...);
        autofill(jt);
        jt.stx = st(jt);
        return jt;
    }

    template <class JsonValue, class... FN>
    JTx
    jtnofill(JsonValue&& jv, FN const&... fN)
    {
        JTx jt(std::forward<JsonValue>(jv));
        invoke(jt, fN...);
        autofillSig(jt);
        jt.stx = st(jt);
        return jt;
    }

    template <class JsonValue, class... FN>
    json::Value
    json(JsonValue&& jv, FN const&... fN)
    {
        auto tj = jt(std::forward<JsonValue>(jv), fN...);
        return std::move(tj.jv);
    }

    template <class... Args>
    void
    require(Args const&... args)
    {
        jtx::required(args...)(*this);
    }

    static ParsedResult
    parseResult(json::Value const& jr);

    virtual void
    submit(JTx const& jt, std::source_location const& loc = std::source_location::current());

    void
    signAndSubmit(
        JTx const& jt,
        json::Value params = json::ValueType::Null,
        std::source_location const& loc = std::source_location::current());

    void
    postconditions(
        JTx const& jt,
        ParsedResult const& parsed,
        json::Value const& jr = json::Value(),
        std::source_location const& loc = std::source_location::current());

    template <class... FN>
    Env&
    apply(WithSourceLocation<json::Value> jv, FN const&... fN)
    {
        submit(jt(std::move(jv.value), fN...), jv.loc);
        return *this;
    }
 
    template <class... FN>
    Env&
    apply(WithSourceLocation<JTx> jv, FN const&... fN)
    {
        submit(jt(std::move(jv.value), fN...), jv.loc);
        return *this;
    }
 
    template <class... FN>
    Env&
    operator()(WithSourceLocation<json::Value> jv, FN const&... fN)
    {
        return apply(std::move(jv), fN...);
    }
 
    template <class... FN>
    Env&
    operator()(WithSourceLocation<JTx> jv, FN const&... fN)
    {
        return apply(std::move(jv), fN...);
    }


    [[nodiscard]] TER
    ter() const
    {
        return ter_;
    }

    std::shared_ptr<STObject const>
    meta();

    [[nodiscard]] std::shared_ptr<STTx const>
    tx() const;
 
    void
    enableFeature(uint256 const feature);
 
    void
    disableFeature(uint256 const feature);
 
    [[nodiscard]] bool
    enabled(uint256 feature) const
    {
        return current()->rules().enabled(feature);
    }
 
private:
    [[nodiscard]] bool
    drainServerIo(std::chrono::steady_clock::duration timeout)
    {
        auto barrier = std::make_shared<std::promise<void>>();
        auto future = barrier->get_future();
        boost::asio::post(app().getIOContext(), [barrier]() { barrier->set_value(); });
        return future.wait_for(timeout) == std::future_status::ready;
    }
 
    void
    fund(bool setDefaultRipple, STAmount const& amount, Account const& account);
 
    void
    fundArg(STAmount const& amount, Account const& account)
    {
        fund(true, amount, account);
    }
 
    template <std::size_t N>
    void
    fundArg(STAmount const& amount, std::array<Account, N> const& list)
    {
        for (auto const& account : list)
            fund(false, amount, account);
    }
 
public:
    template <class Arg, class... Args>
    void
    fund(STAmount const& amount, Arg const& arg, Args const&... args)
    {
        fundArg(amount, arg);
        if constexpr (sizeof...(args) > 0)
            fund(amount, args...);
    }

    void
    trust(STAmount const& amount, Account const& account);
 
    template <class... Accounts>
    void
    trust(STAmount const& amount, Account const& to0, Account const& to1, Accounts const&... toN)
    {
        trust(amount, to0);
        trust(amount, to1, toN...);  // NOLINT(readability-suspicious-call-argument)
    }


    std::shared_ptr<STTx const>
    ust(JTx const& jt);
 
protected:
    int trace_ = 0;
    TestStopwatch stopwatch_;
    uint256 txid_;
    TER ter_ = tesSUCCESS;
    bool parseFailureExpected_ = false;
    unsigned retries_ = 5;
 
    json::Value
    doRpc(
        unsigned apiVersion,
        std::vector<std::string> const& args,
        std::unordered_map<std::string, std::string> const& headers = {});
 
    void
    autofillSig(JTx& jt);
 
    virtual void
    autofill(JTx& jt);

    std::shared_ptr<STTx const>
    st(JTx const& jt);
 
    // Invoke funclets on stx
    // Note: The STTx may not be modified
    template <class... FN>
    void
    invoke(STTx& stx, FN const&... fN)
    {
        (fN(*this, stx), ...);
    }
 
    // Invoke funclets on jt
    template <class... FN>
    void
    invoke(JTx& jt, FN const&... fN)
    {
        (fN(*this, jt), ...);
    }
 
    // Map of account IDs to Account
    std::unordered_map<AccountID, Account> map_;
};
 
template <class... Args>
json::Value
Env::rpc(
    unsigned apiVersion,
    std::unordered_map<std::string, std::string> const& headers,
    std::string const& cmd,
    Args&&... args)
{
    return doRpc(apiVersion, std::vector<std::string>{cmd, std::forward<Args>(args)...}, headers);
}
 
template <class... Args>
json::Value
Env::rpc(unsigned apiVersion, std::string const& cmd, Args&&... args)
{
    return rpc(
        apiVersion,
        std::unordered_map<std::string, std::string>(),
        cmd,
        std::forward<Args>(args)...);
}
 
template <class... Args>
json::Value
Env::rpc(
    std::unordered_map<std::string, std::string> const& headers,
    std::string const& cmd,
    Args&&... args)
{
    return doRpc(
        rpc::kApiCommandLineVersion,
        std::vector<std::string>{cmd, std::forward<Args>(args)...},
        headers);
}
 
template <class... Args>
json::Value
Env::rpc(std::string const& cmd, Args&&... args)
{
    return rpc(std::unordered_map<std::string, std::string>(), cmd, std::forward<Args>(args)...);
}
 
}  // namespace xrpl::test::jtx