Validators.hpp

//------------------------------------------------------------------------------
/*
    This file is part of clio: https://github.com/XRPLF/clio
    Copyright (c) 2023, the clio developers.
 
    Permission to use, copy, modify, and distribute this software for any
    purpose with or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL,  DIRECT,  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#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