LoanBrokerCoverClawback.cpp

#include <xrpl/tx/transactors/lending/LoanBrokerCoverClawback.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/Number.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/ledger/ReadView.h>
#include <xrpl/ledger/helpers/LendingHelpers.h>
#include <xrpl/ledger/helpers/TokenHelpers.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/Concepts.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/LedgerFormats.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/Protocol.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STTakesAsset.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/Units.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/tx/Transactor.h>
 
#include <expected>
#include <optional>
#include <variant>
 
namespace xrpl {
 
bool
LoanBrokerCoverClawback::checkExtraFeatures(PreflightContext const& ctx)
{
    return checkLendingProtocolDependencies(ctx.rules, ctx.tx);
}
 
NotTEC
LoanBrokerCoverClawback::preflight(PreflightContext const& ctx)
{
    auto const brokerID = ctx.tx[~sfLoanBrokerID];
    auto const amount = ctx.tx[~sfAmount];
 
    if (!brokerID && !amount)
        return temINVALID;
 
    if (brokerID && *brokerID == beast::kZero)
        return temINVALID;
 
    if (amount)
    {
        // XRP has no counterparty, and thus nobody can claw it back
        if (amount->native())
            return temBAD_AMOUNT;
 
        // Zero is OK, and indicates "take it all" (down to the minimum cover)
        if (*amount < beast::kZero)
            return temBAD_AMOUNT;
 
        // This should be redundant
        if (!isLegalNet(*amount))
            return temBAD_AMOUNT;  // LCOV_EXCL_LINE
 
        if (!brokerID)
        {
            if (amount->holds<MPTIssue>())
                return temINVALID;
 
            auto const account = ctx.tx[sfAccount];
            // Since we don't have a LoanBrokerID, holder _should_ be the loan
            // broker's pseudo-account, but we don't know yet whether it is, so
            // use a generic placeholder name.
            auto const holder = amount->getIssuer();
            if (holder == account || holder == beast::kZero)
                return temINVALID;
        }
    }
 
    return tesSUCCESS;
}
 
std::expected<uint256, TER>
determineBrokerID(ReadView const& view, STTx const& tx)
{
    // If the broker ID was provided in the transaction, that's all we
    // need.
    if (auto const brokerID = tx[~sfLoanBrokerID])
        return *brokerID;
 
    // If the broker ID was not provided, and the amount is either
    // absent or holds a non-IOU - including MPT, something went wrong,
    // because that should have been rejected in preflight().
    auto const dstAmount = tx[~sfAmount];
    if (!dstAmount || !dstAmount->holds<Issue>())
        return std::unexpected{tecINTERNAL};  // LCOV_EXCL_LINE
 
    // Every trust line is bidirectional. Both sides are simultaneously
    // issuer and holder. For this transaction, the Account is acting as
    // a holder, and clawing back funds from the LoanBroker
    // Pseudo-account acting as holder. If the Amount is an IOU, and the
    // `issuer` field specified in that Amount is a LoanBroker
    // Pseudo-account, we can get the LoanBrokerID from there.
    //
    // Thus, Amount.issuer _should_ be the loan broker's
    // pseudo-account, but we don't know yet whether it is.
    auto const maybePseudo = dstAmount->getIssuer();
    auto const sle = view.read(keylet::account(maybePseudo));
 
    // If the account was not found, the transaction can't go further.
    if (!sle)
        return std::unexpected{tecNO_ENTRY};
 
    // If the account was found, and has a LoanBrokerID (and therefore
    // is a pseudo-account), that's the
    // answer we need.
    if (auto const brokerID = sle->at(~sfLoanBrokerID))
        return *brokerID;
 
    // If the account does not have a LoanBrokerID, the transaction
    // can't go further, even if it's a different type of Pseudo-account.
    return std::unexpected{tecOBJECT_NOT_FOUND};
    // Or tecWRONG_ASSET?
}
 
std::expected<Asset, TER>
determineAsset(
    ReadView const& view,
    AccountID const& account,
    AccountID const& brokerPseudoAccountID,
    STAmount const& amount)
{
    if (amount.holds<MPTIssue>())
        return amount.asset();
 
    // An IOU has an issue, which could be either end of the trust line.
    // This check only applies to IOUs
    auto const holder = amount.getIssuer();
 
    // holder can be the submitting account (the issuer of the asset) if a
    // LoanBrokerID was provided in the transaction.
    if (holder == account)
    {
        return amount.asset();
    }
    if (holder == brokerPseudoAccountID)
    {
        // We want the asset to match the vault asset, so use the account as the
        // issuer
        return Issue{amount.get<Issue>().currency, account};
    }
 
    return std::unexpected(tecWRONG_ASSET);
}
 
std::expected<STAmount, TER>
determineClawAmount(
    SLE const& sleBroker,
    Asset const& vaultAsset,
    std::optional<STAmount> const& amount,
    SLE::const_ref vaultSle,
    Rules const& rules)
{
    auto const maxClawAmount = [&]() {
        auto const minRequiredCover = [&]() {
            if (rules.enabled(fixCleanup3_2_0))
            {
                return minimumBrokerCover(
                    sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum]), vaultSle);
            }
 
            // Always round the minimum required up
            NumberRoundModeGuard const mg(Number::RoundingMode::Upward);
            return tenthBipsOfValue(
                sleBroker[sfDebtTotal], TenthBips32(sleBroker[sfCoverRateMinimum]));
        }();
        // The subtraction probably won't round, but round down if it does.
        NumberRoundModeGuard const mg(Number::RoundingMode::Downward);
        return sleBroker[sfCoverAvailable] - minRequiredCover;
    }();
    if (maxClawAmount <= beast::kZero)
        return std::unexpected(tecINSUFFICIENT_FUNDS);
 
    // Use the vaultAsset here, because it will be the right type in all
    // circumstances. The amount may be an IOU indicating the pseudo-account's
    // asset, which is correct, but not what is needed here.
    if (!amount || *amount == beast::kZero)
        return STAmount{vaultAsset, maxClawAmount};
    Number const magnitude{*amount};
    if (magnitude > maxClawAmount)
        return STAmount{vaultAsset, maxClawAmount};
    return STAmount{vaultAsset, magnitude};
}
 
template <ValidIssueType T>
static TER
preclaimHelper(PreclaimContext const& ctx, SLE const& sleIssuer, STAmount const& clawAmount);
 
template <>
TER
preclaimHelper<Issue>(PreclaimContext const& ctx, SLE const& sleIssuer, STAmount const& clawAmount)
{
    // If AllowTrustLineClawback is not set or NoFreeze is set, return no
    // permission
    if (!(sleIssuer.isFlag(lsfAllowTrustLineClawback)) || (sleIssuer.isFlag(lsfNoFreeze)))
        return tecNO_PERMISSION;
 
    return tesSUCCESS;
}
 
template <>
TER
preclaimHelper<MPTIssue>(
    PreclaimContext const& ctx,
    SLE const& sleIssuer,
    STAmount const& clawAmount)
{
    auto const issuanceKey = keylet::mptokenIssuance(clawAmount.get<MPTIssue>().getMptID());
    auto const sleIssuance = ctx.view.read(issuanceKey);
    if (!sleIssuance)
        return tecOBJECT_NOT_FOUND;
 
    if (!sleIssuance->isFlag(lsfMPTCanClawback))
        return tecNO_PERMISSION;
 
    // With all the checking already done, this should be impossible
    if (sleIssuance->at(sfIssuer) != sleIssuer[sfAccount])
        return tecINTERNAL;  // LCOV_EXCL_LINE
 
    return tesSUCCESS;
}
 
TER
LoanBrokerCoverClawback::preclaim(PreclaimContext const& ctx)
{
    auto const& tx = ctx.tx;
 
    auto const account = tx[sfAccount];
    auto const findBrokerID = determineBrokerID(ctx.view, tx);
    if (!findBrokerID)
        return findBrokerID.error();
    auto const brokerID = *findBrokerID;
    auto const amount = tx[~sfAmount];
 
    auto const sleBroker = ctx.view.read(keylet::loanBroker(brokerID));
    if (!sleBroker)
    {
        JLOG(ctx.j.warn()) << "LoanBroker does not exist.";
        return tecNO_ENTRY;
    }
 
    auto const brokerPseudoAccountID = sleBroker->at(sfAccount);
 
    auto const vault = ctx.view.read(keylet::vault(sleBroker->at(sfVaultID)));
    if (!vault)
    {
        // LCOV_EXCL_START
        JLOG(ctx.j.fatal()) << "Vault is missing for Broker " << brokerID;
        return tefBAD_LEDGER;
        // LCOV_EXCL_STOP
    }
 
    auto const vaultAsset = vault->at(sfAsset);
 
    if (vaultAsset.native())
    {
        JLOG(ctx.j.warn()) << "Cannot clawback native asset.";
        return tecNO_PERMISSION;
    }
 
    // Only the issuer of the vault asset can claw it back from the broker's
    // cover funds.
    if (vaultAsset.getIssuer() != account)
    {
        JLOG(ctx.j.warn()) << "Account is not the issuer of the vault asset.";
        return tecNO_PERMISSION;
    }
 
    if (amount)
    {
        auto const findAsset = determineAsset(ctx.view, account, brokerPseudoAccountID, *amount);
        if (!findAsset)
            return findAsset.error();
        auto const txAsset = *findAsset;
        if (txAsset != vaultAsset)
        {
            JLOG(ctx.j.warn()) << "Account is the correct issuer, but trying "
                                  "to clawback the wrong asset from LoanBroker";
            return tecWRONG_ASSET;
        }
    }
 
    auto const findClawAmount =
        determineClawAmount(*sleBroker, vaultAsset, amount, vault, ctx.view.rules());
    if (!findClawAmount)
    {
        JLOG(ctx.j.warn()) << "LoanBroker cover is already at minimum.";
        return findClawAmount.error();
    }
    STAmount const& clawAmount = *findClawAmount;
 
    if (auto const ret = canApplyToBrokerCover(
            ctx.view, sleBroker, vaultAsset, clawAmount, ctx.j, "LoanBrokerCoverClawback"))
        return ret;
 
    // Explicitly check the balance of the trust line / MPT to make sure the
    // balance is actually there. It should always match `sfCoverAvailable`, so
    // if there isn't, this is an internal error.
    if (accountHolds(
            ctx.view,
            brokerPseudoAccountID,
            vaultAsset,
            FreezeHandling::IgnoreFreeze,
            AuthHandling::IgnoreAuth,
            ctx.j) < clawAmount)
        return tecINTERNAL;  // tecINSUFFICIENT_FUNDS; LCOV_EXCL_LINE
 
    // Check if the vault asset issuer has the correct flags
    auto const sleIssuer = ctx.view.read(keylet::account(vaultAsset.getIssuer()));
    if (!sleIssuer)
    {
        // LCOV_EXCL_START
        JLOG(ctx.j.fatal()) << "Issuer account does not exist.";
        return tefBAD_LEDGER;
        // LCOV_EXCL_STOP
    }
 
    return std::visit(
        [&]<typename T>(T const&) { return preclaimHelper<T>(ctx, *sleIssuer, clawAmount); },
        vaultAsset.value());
}
 
TER
LoanBrokerCoverClawback::doApply()
{
    auto const& tx = ctx_.tx;
    auto const account = tx[sfAccount];
    auto const findBrokerID = determineBrokerID(view(), tx);
    if (!findBrokerID)
        return tecINTERNAL;  // LCOV_EXCL_LINE
    auto const brokerID = *findBrokerID;
    auto const amount = tx[~sfAmount];
 
    auto sleBroker = view().peek(keylet::loanBroker(brokerID));
    if (!sleBroker)
        return tecINTERNAL;  // LCOV_EXCL_LINE
 
    auto const brokerPseudoID = *sleBroker->at(sfAccount);
 
    auto const vault = view().read(keylet::vault(sleBroker->at(sfVaultID)));
    if (!vault)
        return tecINTERNAL;  // LCOV_EXCL_LINE
 
    auto const vaultAsset = vault->at(sfAsset);
 
    auto const findClawAmount =
        determineClawAmount(*sleBroker, vaultAsset, amount, vault, view().rules());
    if (!findClawAmount)
        return tecINTERNAL;  // LCOV_EXCL_LINE
    STAmount const& clawAmount = *findClawAmount;
    // Just for paranoia's sake
    if (clawAmount.native())
        return tecINTERNAL;  // LCOV_EXCL_LINE
 
    // Decrease the LoanBroker's CoverAvailable by Amount
    sleBroker->at(sfCoverAvailable) -= clawAmount;
    view().update(sleBroker);
 
    associateAsset(*sleBroker, vaultAsset);
 
    // Transfer assets from pseudo-account to depositor.
    return accountSend(view(), brokerPseudoID, account, clawAmount, j_, WaiveTransferFee::Yes);
}
 
void
LoanBrokerCoverClawback::visitInvariantEntry(bool, SLE::const_ref, SLE::const_ref)
{
    // No transaction-specific invariants yet (future work).
}
 
bool
LoanBrokerCoverClawback::finalizeInvariants(
    STTx const&,
    TER,
    XRPAmount,
    ReadView const&,
    beast::Journal const&)
{
    // No transaction-specific invariants yet (future work).
    return true;
}
 
//------------------------------------------------------------------------------
 
}  // namespace xrpl