JsonUtils.hpp

#pragma once
 
#include "rpc/JS.hpp"
 
#include <boost/json.hpp>
#include <boost/json/object.hpp>
#include <xrpl/beast/core/LexicalCast.h>
 
#include <algorithm>
#include <cctype>
#include <charconv>
#include <concepts>
#include <expected>
#include <stdexcept>
#include <string>

namespace util {

inline std::string
toLower(std::string str)
{
    std::ranges::transform(str, std::begin(str), [](unsigned char c) { return std::tolower(c); });
    return str;
}

inline std::string
toUpper(std::string str)
{
    std::ranges::transform(str, std::begin(str), [](unsigned char c) { return std::toupper(c); });
    return str;
}

inline boost::json::object
removeSecret(boost::json::object const& object)
{
    auto newObject = object;
    auto const secretFields = {"secret", "seed", "seed_hex", "passphrase"};
 
    if (newObject.contains("params") and newObject.at("params").is_array() and
        not newObject.at("params").as_array().empty() and
        newObject.at("params").as_array()[0].is_object()) {
        for (auto const& secretField : secretFields) {
            if (newObject.at("params").as_array()[0].as_object().contains(secretField))
                newObject.at("params").as_array()[0].as_object()[secretField] = "*";
        }
    }
 
    // for websocket requests
    for (auto const& secretField : secretFields) {
        if (newObject.contains(secretField))
            newObject[secretField] = "*";
    }
 
    return newObject;
}

template <std::integral Type>
std::expected<Type, std::string>
tryIntegralValueAs(boost::json::value const& value)
{
    if (value.is_uint64())
        return static_cast<Type>(value.as_uint64());
 
    if (value.is_int64())
        return static_cast<Type>(value.as_int64());
 
    return std::unexpected("Value neither uint64 nor int64");
}

template <std::integral Type>
Type
integralValueAs(boost::json::value const& value)
{
    auto expectedResult = tryIntegralValueAs<Type>(value);
    if (expectedResult.has_value())
        return *expectedResult;
 
    throw std::logic_error(std::move(expectedResult).error());
}

[[nodiscard]] inline std::expected<uint32_t, std::string>
getLedgerIndex(boost::json::value const& value)
{
    if (not value.is_string()) {
        return tryIntegralValueAs<uint32_t>(value);
    }
    if (value.as_string() != "validated") {
        uint32_t ledgerIndex{};
        if (beast::lexicalCastChecked(ledgerIndex, value.as_string().c_str())) {
            return ledgerIndex;
        }
        return std::unexpected("Invalid ledger index string");
    }
    return std::unexpected("'validated' ledger index is requested");
}
 
}  // namespace util