LedgerEntryHelpers.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012-2025 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or 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.
*/
//==============================================================================
 
#include <xrpld/rpc/detail/RPCHelpers.h>
 
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/basics/strHex.h>
#include <xrpl/beast/core/LexicalCast.h>
#include <xrpl/json/json_errors.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/RPCErr.h>
#include <xrpl/protocol/STXChainBridge.h>
#include <xrpl/protocol/jss.h>
 
#include <functional>
 
namespace ripple {
 
namespace LedgerEntryHelpers {
 
Unexpected<Json::Value>
missingFieldError(
    Json::StaticString const field,
    std::optional<std::string> err = std::nullopt)
{
    Json::Value json = Json::objectValue;
    auto error = RPC::missing_field_message(std::string(field.c_str()));
    json[jss::error] = err.value_or("malformedRequest");
    json[jss::error_code] = rpcINVALID_PARAMS;
    json[jss::error_message] = std::move(error);
    return Unexpected(json);
}
 
Unexpected<Json::Value>
invalidFieldError(
    std::string const& err,
    Json::StaticString const field,
    std::string const& type)
{
    Json::Value json = Json::objectValue;
    auto error = RPC::expected_field_message(field, type);
    json[jss::error] = err;
    json[jss::error_code] = rpcINVALID_PARAMS;
    json[jss::error_message] = std::move(error);
    return Unexpected(json);
}
 
Unexpected<Json::Value>
malformedError(std::string const& err, std::string const& message)
{
    Json::Value json = Json::objectValue;
    json[jss::error] = err;
    json[jss::error_code] = rpcINVALID_PARAMS;
    json[jss::error_message] = message;
    return Unexpected(json);
}
 
Expected<bool, Json::Value>
hasRequired(
    Json::Value const& params,
    std::initializer_list<Json::StaticString> fields,
    std::optional<std::string> err = std::nullopt)
{
    for (auto const field : fields)
    {
        if (!params.isMember(field) || params[field].isNull())
        {
            return missingFieldError(field, err);
        }
    }
    return true;
}
 
template <class T>
std::optional<T>
parse(Json::Value const& param);
 
template <class T>
Expected<T, Json::Value>
required(
    Json::Value const& params,
    Json::StaticString const fieldName,
    std::string const& err,
    std::string const& expectedType)
{
    if (!params.isMember(fieldName) || params[fieldName].isNull())
    {
        return missingFieldError(fieldName);
    }
    if (auto obj = parse<T>(params[fieldName]))
    {
        return *obj;
    }
    return invalidFieldError(err, fieldName, expectedType);
}
 
template <>
std::optional<AccountID>
parse(Json::Value const& param)
{
    if (!param.isString())
        return std::nullopt;
 
    auto const account = parseBase58<AccountID>(param.asString());
    if (!account || account->isZero())
    {
        return std::nullopt;
    }
 
    return account;
}
 
Expected<AccountID, Json::Value>
requiredAccountID(
    Json::Value const& params,
    Json::StaticString const fieldName,
    std::string const& err)
{
    return required<AccountID>(params, fieldName, err, "AccountID");
}
 
std::optional<Blob>
parseHexBlob(Json::Value const& param, std::size_t maxLength)
{
    if (!param.isString())
        return std::nullopt;
 
    auto const blob = strUnHex(param.asString());
    if (!blob || blob->empty() || blob->size() > maxLength)
        return std::nullopt;
 
    return blob;
}
 
Expected<Blob, Json::Value>
requiredHexBlob(
    Json::Value const& params,
    Json::StaticString const fieldName,
    std::size_t maxLength,
    std::string const& err)
{
    if (!params.isMember(fieldName) || params[fieldName].isNull())
    {
        return missingFieldError(fieldName);
    }
    if (auto blob = parseHexBlob(params[fieldName], maxLength))
    {
        return *blob;
    }
    return invalidFieldError(err, fieldName, "hex string");
}
 
template <>
std::optional<std::uint32_t>
parse(Json::Value const& param)
{
    if (param.isUInt() || (param.isInt() && param.asInt() >= 0))
        return param.asUInt();
 
    if (param.isString())
    {
        std::uint32_t v;
        if (beast::lexicalCastChecked(v, param.asString()))
            return v;
    }
 
    return std::nullopt;
}
 
Expected<std::uint32_t, Json::Value>
requiredUInt32(
    Json::Value const& params,
    Json::StaticString const fieldName,
    std::string const& err)
{
    return required<std::uint32_t>(params, fieldName, err, "number");
}
 
template <>
std::optional<uint256>
parse(Json::Value const& param)
{
    uint256 uNodeIndex;
    if (!param.isString() || !uNodeIndex.parseHex(param.asString()))
    {
        return std::nullopt;
    }
 
    return uNodeIndex;
}
 
Expected<uint256, Json::Value>
requiredUInt256(
    Json::Value const& params,
    Json::StaticString const fieldName,
    std::string const& err)
{
    return required<uint256>(params, fieldName, err, "Hash256");
}
 
template <>
std::optional<uint192>
parse(Json::Value const& param)
{
    uint192 field;
    if (!param.isString() || !field.parseHex(param.asString()))
    {
        return std::nullopt;
    }
 
    return field;
}
 
Expected<uint192, Json::Value>
requiredUInt192(
    Json::Value const& params,
    Json::StaticString const fieldName,
    std::string const& err)
{
    return required<uint192>(params, fieldName, err, "Hash192");
}
 
Expected<STXChainBridge, Json::Value>
parseBridgeFields(Json::Value const& params)
{
    if (auto const value = hasRequired(
            params,
            {jss::LockingChainDoor,
             jss::LockingChainIssue,
             jss::IssuingChainDoor,
             jss::IssuingChainIssue});
        !value)
    {
        return Unexpected(value.error());
    }
 
    auto const lockingChainDoor = requiredAccountID(
        params, jss::LockingChainDoor, "malformedLockingChainDoor");
    if (!lockingChainDoor)
    {
        return Unexpected(lockingChainDoor.error());
    }
 
    auto const issuingChainDoor = requiredAccountID(
        params, jss::IssuingChainDoor, "malformedIssuingChainDoor");
    if (!issuingChainDoor)
    {
        return Unexpected(issuingChainDoor.error());
    }
 
    Issue lockingChainIssue;
    try
    {
        lockingChainIssue = issueFromJson(params[jss::LockingChainIssue]);
    }
    catch (std::runtime_error const& ex)
    {
        return invalidFieldError(
            "malformedIssue", jss::LockingChainIssue, "Issue");
    }
 
    Issue issuingChainIssue;
    try
    {
        issuingChainIssue = issueFromJson(params[jss::IssuingChainIssue]);
    }
    catch (std::runtime_error const& ex)
    {
        return invalidFieldError(
            "malformedIssue", jss::IssuingChainIssue, "Issue");
    }
 
    return STXChainBridge(
        *lockingChainDoor,
        lockingChainIssue,
        *issuingChainDoor,
        issuingChainIssue);
}
 
}  // namespace LedgerEntryHelpers
 
}  // namespace ripple