Validators.hpp

#pragma once
 
#include "rpc/Errors.hpp"
#include "rpc/common/Types.hpp"
#include "rpc/common/ValidationHelpers.hpp"
 
#include <boost/json/array.hpp>
#include <boost/json/object.hpp>
#include <boost/json/value.hpp>
#include <fmt/format.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/protocol/ErrorCodes.h>
 
#include <concepts>
#include <ctime>
#include <functional>
#include <initializer_list>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace rpc::validation {

struct Required final {
    [[nodiscard]] static MaybeError
    verify(boost::json::value const& value, std::string_view key);
};

template <typename... T>
class NotSupported;

template <typename T>
class NotSupported<T> final {
    T value_;
 
public:
    NotSupported(T val) : value_(val)
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
    {
        if (value.is_object() and value.as_object().contains(key)) {
            using boost::json::value_to;
            auto const res = value_to<T>(value.as_object().at(key));
            if (value_ == res) {
                return Error{Status{
                    RippledError::rpcNOT_SUPPORTED,
                    fmt::format("Not supported field '{}'s value '{}'", std::string{key}, res)
                }};
            }
        }
        return {};
    }
};

template <>
class NotSupported<> final {
public:
    [[nodiscard]] static MaybeError
    verify(boost::json::value const& value, std::string_view key)
    {
        if (value.is_object() and value.as_object().contains(key)) {
            return Error{Status{
                RippledError::rpcNOT_SUPPORTED, "Not supported field '" + std::string{key} + '\''
            }};
        }
 
        return {};
    }
};

template <typename... T>
NotSupported(T&&... t) -> NotSupported<T...>;

template <typename... Types>
struct Type final {
    [[nodiscard]] MaybeError
    verify(boost::json::value& value, std::string_view key) const
    {
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. If field is supposed to exist, let 'required' fail instead
 
        auto& res = value.as_object().at(key);
        auto const convertible = (checkTypeAndClamp<Types>(res) || ...);
 
        if (not convertible)
            return Error{Status{RippledError::rpcINVALID_PARAMS}};
 
        return {};
    }
};

template <typename Type>
class Between final {
    Type min_;
    Type max_;
 
public:
    explicit Between(Type min, Type max) : min_{min}, max_{max}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
    {
        using boost::json::value_to;
 
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        auto const res = value_to<Type>(value.as_object().at(key));
 
        // TODO: may want a way to make this code more generic (e.g. use a free
        // function that can be overridden for this comparison)
        if (res < min_ || res > max_)
            return Error{Status{RippledError::rpcINVALID_PARAMS}};
 
        return {};
    }
};

template <typename Type>
class Min final {
    Type min_;
 
public:
    explicit Min(Type min) : min_{min}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
    {
        using boost::json::value_to;
 
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        auto const res = value_to<Type>(value.as_object().at(key));
 
        if (res < min_)
            return Error{Status{RippledError::rpcINVALID_PARAMS}};
 
        return {};
    }
};

template <typename Type>
class Max final {
    Type max_;
 
public:
    explicit Max(Type max) : max_{max}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
    {
        using boost::json::value_to;
 
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        auto const res = value_to<Type>(value.as_object().at(key));
 
        if (res > max_)
            return Error{Status{RippledError::rpcINVALID_PARAMS}};
 
        return {};
    }
};

class TimeFormatValidator final {
    std::string format_;
 
public:
    explicit TimeFormatValidator(std::string format) : format_{std::move(format)}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const;
};

template <typename Type>
class EqualTo final {
    Type original_;
 
public:
    explicit EqualTo(Type original) : original_{std::move(original)}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
    {
        using boost::json::value_to;
 
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        auto const res = value_to<Type>(value.as_object().at(key));
        if (res != original_)
            return Error{Status{RippledError::rpcINVALID_PARAMS}};
 
        return {};
    }
};

EqualTo(char const*) -> EqualTo<std::string>;

template <typename Type>
class OneOf final {
    std::vector<Type> options_;
 
public:
    explicit OneOf(std::initializer_list<Type> options) : options_{options}
    {
    }

    template <typename InputIt>
    explicit OneOf(InputIt begin, InputIt end) : options_{begin, end}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const
    {
        using boost::json::value_to;
 
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. field does not exist, let 'required' fail instead
 
        auto const res = value_to<Type>(value.as_object().at(key));
        if (std::find(std::begin(options_), std::end(options_), res) == std::end(options_)) {
            return Error{
                Status{RippledError::rpcINVALID_PARAMS, fmt::format("Invalid field '{}'.", key)}
            };
        }
 
        return {};
    }
};

OneOf(std::initializer_list<char const*>) -> OneOf<std::string>;

class CustomValidator final {
    std::function<MaybeError(boost::json::value const&, std::string_view)> validator_;
 
public:
    template <typename Fn>
        requires std::invocable<Fn, boost::json::value const&, std::string_view>
    explicit CustomValidator(Fn&& fn) : validator_{std::forward<Fn>(fn)}
    {
    }

    [[nodiscard]] MaybeError
    verify(boost::json::value const& value, std::string_view key) const;
};

[[nodiscard]] bool
checkIsU32Numeric(std::string_view sv);
 
template <class HexType>
    requires(
        std::is_same_v<HexType, ripple::uint160> || std::is_same_v<HexType, ripple::uint192> ||
        std::is_same_v<HexType, ripple::uint256>
    )
MaybeError
makeHexStringValidator(boost::json::value const& value, std::string_view key)
{
    if (!value.is_string())
        return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "NotString"}};
 
    HexType parsedInt;
    if (!parsedInt.parseHex(value.as_string().c_str()))
        return Error{Status{RippledError::rpcINVALID_PARAMS, std::string(key) + "Malformed"}};
 
    return MaybeError{};
}

struct CustomValidators final {
    static CustomValidator ledgerIndexValidator;

    static CustomValidator ledgerTypeValidator;

    static CustomValidator accountValidator;

    static CustomValidator accountBase58Validator;

    static CustomValidator accountMarkerValidator;

    static CustomValidator accountTypeValidator;

    static CustomValidator uint160HexStringValidator;

    static CustomValidator uint192HexStringValidator;

    static CustomValidator uint256HexStringValidator;

    static CustomValidator currencyValidator;

    static CustomValidator issuerValidator;

    static CustomValidator subscribeStreamValidator;

    static CustomValidator subscribeAccountsValidator;

    static CustomValidator currencyIssueValidator;

    static CustomValidator authorizeCredentialValidator;

    static CustomValidator credentialTypeValidator;
};

struct Hex256ItemType final {
    [[nodiscard]] static MaybeError
    verify(boost::json::value const& value, std::string_view key)
    {
        if (not value.is_object() or not value.as_object().contains(key))
            return {};  // ignore. If field is supposed to exist, let 'required' fail instead
 
        auto const& res = value.as_object().at(key);
 
        // loop through each item in the array and make sure it is uint256 hex string
        for (auto const& elem : res.as_array()) {
            ripple::uint256 num;
            if (!elem.is_string() || !num.parseHex(elem.as_string())) {
                return Error{
                    Status{RippledError::rpcINVALID_PARAMS, "Item is not a valid uint256 type."}
                };
            }
        }
        return {};
    }
};
 
}  // namespace rpc::validation