AccountLines.cpp

#include <xrpld/rpc/Context.h>
#include <xrpld/rpc/detail/RPCHelpers.h>
#include <xrpld/rpc/detail/RPCLedgerHelpers.h>
#include <xrpld/rpc/detail/TrustLine.h>
#include <xrpld/rpc/detail/Tuning.h>
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/json/json_value.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/helpers/DirectoryHelpers.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/RPCErr.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/UintTypes.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/resource/Fees.h>
 
#include <boost/lexical_cast.hpp>
#include <boost/lexical_cast/bad_lexical_cast.hpp>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <vector>
 
namespace xrpl {
 
void
addLine(json::Value& jsonLines, RPCTrustLine const& line)
{
    STAmount const& saBalance(line.getBalance());
    STAmount const& saLimit(line.getLimit());
    STAmount const& saLimitPeer(line.getLimitPeer());
    json::Value& jPeer(jsonLines.append(json::ValueType::Object));
 
    jPeer[jss::account] = to_string(line.getAccountIDPeer());
    // Amount reported is positive if current account holds other
    // account's IOUs.
    //
    // Amount reported is negative if other account holds current
    // account's IOUs.
    jPeer[jss::balance] = saBalance.getText();
    jPeer[jss::currency] = to_string(saBalance.get<Issue>().currency);
    jPeer[jss::limit] = saLimit.getText();
    jPeer[jss::limit_peer] = saLimitPeer.getText();
    jPeer[jss::quality_in] = line.getQualityIn().value;
    jPeer[jss::quality_out] = line.getQualityOut().value;
    if (line.getAuth())
        jPeer[jss::authorized] = true;
    if (line.getAuthPeer())
        jPeer[jss::peer_authorized] = true;
    if (line.getNoRipple())
        jPeer[jss::no_ripple] = true;
    if (line.getNoRipplePeer())
        jPeer[jss::no_ripple_peer] = true;
    if (line.getFreeze())
        jPeer[jss::freeze] = true;
    if (line.getFreezePeer())
        jPeer[jss::freeze_peer] = true;
    if (line.getDeepFreeze())
        jPeer[jss::deep_freeze] = true;
    if (line.getDeepFreezePeer())
        jPeer[jss::deep_freeze_peer] = true;
}
 
// {
//   account: <account>
//   ledger_hash : <ledger>
//   ledger_index : <ledger_index>
//   limit: integer                 // optional
//   marker: opaque                 // optional, resume previous query
//   ignore_default: bool           // do not return lines in default state (on
//   this account's side)
// }
json::Value
doAccountLines(RPC::JsonContext& context)
{
    auto const& params(context.params);
    if (!params.isMember(jss::account))
        return RPC::missingFieldError(jss::account);
 
    if (!params[jss::account].isString())
        return RPC::invalidFieldError(jss::account);
 
    std::shared_ptr<ReadView const> ledger;
    auto result = RPC::lookupLedger(ledger, context);
    if (!ledger)
        return result;
 
    auto id = parseBase58<AccountID>(params[jss::account].asString());
    if (!id)
    {
        RPC::injectError(RpcActMalformed, result);
        return result;
    }
    auto const accountID{id.value()};
 
    if (!ledger->exists(keylet::account(accountID)))
        return rpcError(RpcActNotFound);
 
    std::string strPeer;
    if (params.isMember(jss::peer))
        strPeer = params[jss::peer].asString();
 
    auto const raPeerAccount = [&]() -> std::optional<AccountID> {
        return strPeer.empty() ? std::nullopt : parseBase58<AccountID>(strPeer);
    }();
    if (!strPeer.empty() && !raPeerAccount)
    {
        RPC::injectError(RpcActMalformed, result);
        return result;
    }
 
    unsigned int limit = 0;
    if (auto err = readLimitField(limit, RPC::Tuning::kAccountLines, context))
        return *err;
 
    // this flag allows the requester to ask incoming trustlines in default
    // state be omitted
    bool const ignoreDefault =
        params.isMember(jss::ignore_default) && params[jss::ignore_default].asBool();
 
    json::Value& jsonLines(result[jss::lines] = json::ValueType::Array);
    struct VisitData
    {
        std::vector<RPCTrustLine> items;
        AccountID const& accountID;
        std::optional<AccountID> const& raPeerAccount;
        bool ignoreDefault;
        uint32_t foundCount;
    };
    VisitData visitData = {
        .items = {},
        .accountID = accountID,
        .raPeerAccount = raPeerAccount,
        .ignoreDefault = ignoreDefault,
        .foundCount = 0};
    uint256 startAfter = beast::kZero;
    std::uint64_t startHint = 0;
 
    if (params.isMember(jss::marker))
    {
        if (!params[jss::marker].isString())
            return RPC::expectedFieldError(jss::marker, "string");
 
        // Marker is composed of a comma separated index and start hint. The
        // former will be read as hex, and the latter using boost lexical cast.
        std::stringstream marker(params[jss::marker].asString());
        std::string value;
        if (!std::getline(marker, value, ','))
            return rpcError(RpcInvalidParams);
 
        if (!startAfter.parseHex(value))
            return rpcError(RpcInvalidParams);
 
        if (!std::getline(marker, value, ','))
            return rpcError(RpcInvalidParams);
 
        try
        {
            startHint = boost::lexical_cast<std::uint64_t>(value);
        }
        catch (boost::bad_lexical_cast&)
        {
            return rpcError(RpcInvalidParams);
        }
 
        // We then must check if the object pointed to by the marker is actually
        // owned by the account in the request.
        auto const sle = ledger->read({ltANY, startAfter});
 
        if (!sle)
            return rpcError(RpcInvalidParams);
 
        if (!RPC::isRelatedToAccount(*ledger, sle, accountID))
            return rpcError(RpcInvalidParams);
    }
 
    auto count = 0;
    std::optional<uint256> marker = {};
    std::uint64_t nextHint = 0;
    {
        if (!forEachItemAfter(
                *ledger,
                accountID,
                startAfter,
                startHint,
                limit + 1,
                [&visitData, &count, &marker, &limit, &nextHint](SLE::const_ref sleCur) {
                    if (!sleCur)
                    {
                        // LCOV_EXCL_START
                        UNREACHABLE("xrpl::doAccountLines : null SLE");
                        return false;
                        // LCOV_EXCL_STOP
                    }
 
                    if (++count == limit)
                    {
                        marker = sleCur->key();
                        nextHint = RPC::getStartHint(sleCur, visitData.accountID);
                    }
 
                    if (sleCur->getType() != ltRIPPLE_STATE)
                        return true;
 
                    bool ignore = false;
                    if (visitData.ignoreDefault)
                    {
                        if (sleCur->getFieldAmount(sfLowLimit).getIssuer() == visitData.accountID)
                        {
                            ignore = !sleCur->isFlag(lsfLowReserve);
                        }
                        else
                        {
                            ignore = !sleCur->isFlag(lsfHighReserve);
                        }
                    }
 
                    if (!ignore && count <= limit)
                    {
                        auto const line = RPCTrustLine::makeItem(visitData.accountID, sleCur);
 
                        if (line &&
                            (!visitData.raPeerAccount ||
                             *visitData.raPeerAccount == line->getAccountIDPeer()))
                        {
                            visitData.items.emplace_back(*line);
                        }
                    }
 
                    return true;
                }))
        {
            return rpcError(RpcInvalidParams);
        }
    }
 
    // Both conditions need to be checked because marker is set on the limit-th
    // item, but if there is no item on the limit + 1 iteration, then there is
    // no need to return a marker.
    if (count == limit + 1 && marker)
    {
        result[jss::limit] = limit;
        result[jss::marker] = to_string(*marker) + "," + std::to_string(nextHint);
    }
 
    result[jss::account] = toBase58(accountID);
 
    for (auto const& item : visitData.items)
        addLine(jsonLines, item);
 
    context.loadType = Resource::kFeeMediumBurdenRpc;
    return result;
}
 
}  // namespace xrpl