AccountRootHelpers.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Rate.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/XRPAmount.h>
 
#include <cstdint>
#include <expected>
#include <optional>
#include <vector>
 
namespace xrpl {

[[nodiscard]] bool
isGlobalFrozen(ReadView const& view, AccountID const& issuer);

[[nodiscard]] XRPAmount
xrpLiquid(ReadView const& view, AccountID const& id, std::int32_t ownerCountAdj, beast::Journal j);
 
struct Adjustment
{
    std::int32_t ownerCountDelta = 0;
    std::int32_t accountCountDelta = 0;
};

[[nodiscard]] XRPAmount
accountReserve(ReadView const& view, SLE::ConstRef sle, beast::Journal j, Adjustment adj = {});

[[nodiscard]] inline XRPAmount
accountReserve(ReadView const& view, AccountID const& id, beast::Journal j, Adjustment adj = {})
{
    return accountReserve(view, view.read(keylet::account(id)), j, adj);
}

[[nodiscard]] TER
checkReserve(
    ApplyViewContext ctx,
    SLE::ConstRef accSle,
    XRPAmount accBalance,
    SLE::ConstRef sponsorSle,
    Adjustment adj,
    beast::Journal j,
    TER insufReserveCode = tecINSUFFICIENT_RESERVE);

[[nodiscard]] TER
checkReserve(
    ApplyViewContext ctx,
    SLE::ConstRef accSle,
    XRPAmount accBalance,
    Adjustment adj,
    beast::Journal j = beast::Journal{beast::Journal::getNullSink()});

std::uint32_t
ownerCount(SLE::ConstRef sle, beast::Journal j, std::int32_t ownerCountAdj = 0);

void
increaseOwnerCount(
    ApplyView& view,
    SLE::Ref accountSle,
    SLE::Ref sponsorSle,
    std::uint32_t count,
    beast::Journal j);

void
increaseOwnerCount(
    ApplyViewContext ctx,
    SLE::Ref accountSle,
    std::uint32_t count,
    beast::Journal j);

inline void
increaseOwnerCount(
    ApplyView& view,
    AccountID const& account,
    std::optional<AccountID> const& sponsor,
    std::uint32_t count,
    beast::Journal j)
{
    increaseOwnerCount(
        view,
        view.peek(keylet::account(account)),
        sponsor ? view.peek(keylet::account(*sponsor)) : SLE::pointer(),
        count,
        j);
}

void
decreaseOwnerCount(
    ApplyView& view,
    SLE::Ref accountSle,
    SLE::Ref sponsorSle,
    std::uint32_t count,
    beast::Journal j);

inline void
decreaseOwnerCount(
    ApplyView& view,
    AccountID const& account,
    std::optional<AccountID> const& sponsor,
    std::uint32_t count,
    beast::Journal j)
{
    decreaseOwnerCount(
        view,
        view.peek(keylet::account(account)),
        sponsor ? view.peek(keylet::account(*sponsor)) : SLE::pointer(),
        count,
        j);
}

void
decreaseOwnerCountForObject(
    ApplyView& view,
    SLE::Ref accountSle,
    SLE::Ref objectSle,
    std::uint32_t count,
    beast::Journal j);

inline void
decreaseOwnerCountForObject(
    ApplyView& view,
    AccountID const& account,
    SLE::Ref objectSle,
    std::uint32_t count,
    beast::Journal j)
{
    SLE::Ref accountSle = view.peek(keylet::account(account));
    decreaseOwnerCountForObject(view, accountSle, objectSle, count, j);
}

void
adjustLoanBrokerOwnerCount(
    ApplyView& view,
    SLE::Ref brokerSle,
    std::int32_t delta,
    beast::Journal j);

[[nodiscard]] Rate
transferRate(ReadView const& view, AccountID const& issuer);

AccountID
pseudoAccountAddress(ReadView const& view, UInt256 const& pseudoOwnerKey);

[[nodiscard]] std::vector<SField const*> const&
getPseudoAccountFields();

[[nodiscard]] bool
isPseudoAccount(SLE::const_pointer sleAcct);

[[nodiscard]] inline bool
isPseudoAccount(ReadView const& view, AccountID const& accountId)
{
    return isPseudoAccount(view.read(keylet::account(accountId)));
}

[[nodiscard]] std::expected<SLE::pointer, TER>
createPseudoAccount(ApplyView& view, UInt256 const& pseudoOwnerKey, SField const& ownerField);

[[nodiscard]] TER
checkDestinationAndTag(SLE::ConstRef toSle, bool hasDestinationTag);
 
}  // namespace xrpl