AMMDeposit.cpp

#include <xrpl/tx/transactors/dex/AMMDeposit.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/Number.h>
#include <xrpl/beast/utility/Zero.h>
#include <xrpl/beast/utility/instrumentation.h>
#include <xrpl/ledger/Sandbox.h>
#include <xrpl/ledger/helpers/AMMHelpers.h>
#include <xrpl/ledger/helpers/AccountRootHelpers.h>
#include <xrpl/ledger/helpers/MPTokenHelpers.h>
#include <xrpl/ledger/helpers/TokenHelpers.h>
#include <xrpl/protocol/AMMCore.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Asset.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/MPTIssue.h>
#include <xrpl/protocol/SField.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/STTx.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/TxFlags.h>
#include <xrpl/protocol/XRPAmount.h>
#include <xrpl/tx/Transactor.h>
 
#include <bit>
#include <cstdint>
#include <exception>
#include <optional>
#include <stdexcept>
#include <utility>
 
namespace xrpl {
 
bool
AMMDeposit::checkExtraFeatures(PreflightContext const& ctx)
{
    if (!ammEnabled(ctx.rules))
        return false;
 
    auto const amount = ctx.tx[~sfAmount];
    auto const amount2 = ctx.tx[~sfAmount2];
 
    return ctx.rules.enabled(featureMPTokensV2) ||
        (!ctx.tx[sfAsset].holds<MPTIssue>() && !ctx.tx[sfAsset2].holds<MPTIssue>() &&
         !(amount && amount->holds<MPTIssue>()) && !(amount2 && amount2->holds<MPTIssue>()));
}
 
std::uint32_t
AMMDeposit::getFlagsMask(PreflightContext const& ctx)
{
    return tfAMMDepositMask;
}
 
NotTEC
AMMDeposit::preflight(PreflightContext const& ctx)
{
    auto const flags = ctx.tx.getFlags();
    auto const amount = ctx.tx[~sfAmount];
    auto const amount2 = ctx.tx[~sfAmount2];
    auto const ePrice = ctx.tx[~sfEPrice];
    auto const lpTokens = ctx.tx[~sfLPTokenOut];
    auto const tradingFee = ctx.tx[~sfTradingFee];
    // Valid options for the flags are:
    //   tfLPTokens: LPTokenOut, [Amount, Amount2]
    //   tfSingleAsset: Amount, [LPTokenOut]
    //   tfTwoAsset: Amount, Amount2, [LPTokenOut]
    //   tfTwoAssetIfEmpty: Amount, Amount2, [sfTradingFee]
    //   tfOnAssetLPToken: Amount and LPTokenOut
    //   tfLimitLPToken: Amount and EPrice
    if (std::popcount(flags & tfDepositSubTx) != 1)
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: invalid flags.";
        return temMALFORMED;
    }
    if (ctx.tx.isFlag(tfLPToken))
    {
        // if included then both amount and amount2 are deposit min
        if (!lpTokens || ePrice || (amount && !amount2) || (!amount && amount2) || tradingFee)
            return temMALFORMED;
    }
    else if (ctx.tx.isFlag(tfSingleAsset))
    {
        // if included then lpTokens is deposit min
        if (!amount || amount2 || ePrice || tradingFee)
            return temMALFORMED;
    }
    else if (ctx.tx.isFlag(tfTwoAsset))
    {
        // if included then lpTokens is deposit min
        if (!amount || !amount2 || ePrice || tradingFee)
            return temMALFORMED;
    }
    else if (ctx.tx.isFlag(tfOneAssetLPToken))
    {
        if (!amount || !lpTokens || amount2 || ePrice || tradingFee)
            return temMALFORMED;
    }
    else if (ctx.tx.isFlag(tfLimitLPToken))
    {
        if (!amount || !ePrice || lpTokens || amount2 || tradingFee)
            return temMALFORMED;
    }
    else if (ctx.tx.isFlag(tfTwoAssetIfEmpty))
    {
        if (!amount || !amount2 || ePrice || lpTokens)
            return temMALFORMED;
    }
 
    auto const asset = ctx.tx[sfAsset];
    auto const asset2 = ctx.tx[sfAsset2];
    if (auto const res = invalidAMMAssetPair(asset, asset2))
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: invalid asset pair.";
        return res;
    }
 
    if (amount && amount2 && amount->asset() == amount2->asset())
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: invalid tokens, same issue." << amount->asset() << " "
                            << amount2->asset();
        return temBAD_AMM_TOKENS;
    }
 
    if (lpTokens && *lpTokens <= beast::kZero)
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: invalid LPTokens";
        return temBAD_AMM_TOKENS;
    }
 
    if (amount)
    {
        if (auto const res = invalidAMMAmount(
                *amount, std::make_optional(std::make_pair(asset, asset2)), ePrice.has_value()))
        {
            JLOG(ctx.j.debug()) << "AMM Deposit: invalid amount";
            return res;
        }
    }
 
    if (amount2)
    {
        if (auto const res =
                invalidAMMAmount(*amount2, std::make_optional(std::make_pair(asset, asset2))))
        {
            JLOG(ctx.j.debug()) << "AMM Deposit: invalid amount2";
            return res;
        }
    }
 
    if (amount && ePrice)
    {
        auto assets = [&]() -> std::optional<std::pair<Asset, Asset>> {
            // don't check ePrice issue
            if (ctx.rules.enabled(featureMPTokensV2))
                return std::nullopt;
            // must be amount issue
            return std::make_optional(std::make_pair(amount->asset(), amount->asset()));
        }();
        if (auto const res = invalidAMMAmount(*ePrice, assets))
        {
            JLOG(ctx.j.debug()) << "AMM Deposit: invalid EPrice";
            return res;
        }
    }
 
    if (tradingFee > kTradingFeeThreshold)
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: invalid trading fee.";
        return temBAD_FEE;
    }
 
    return tesSUCCESS;
}
 
TER
AMMDeposit::preclaim(PreclaimContext const& ctx)
{
    auto const accountID = ctx.tx[sfAccount];
 
    auto const ammSle = ctx.view.read(keylet::amm(ctx.tx[sfAsset], ctx.tx[sfAsset2]));
    if (!ammSle)
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: Invalid asset pair.";
        return terNO_AMM;
    }
 
    auto const expected = ammHolds(
        ctx.view,
        *ammSle,
        std::nullopt,
        std::nullopt,
        FreezeHandling::IgnoreFreeze,
        AuthHandling::IgnoreAuth,
        ctx.j);
    if (!expected)
        return expected.error();  // LCOV_EXCL_LINE
    auto const [amountBalance, amount2Balance, lptAMMBalance] = *expected;
    if (ctx.tx.isFlag(tfTwoAssetIfEmpty))
    {
        if (lptAMMBalance != beast::kZero)
            return tecAMM_NOT_EMPTY;
        if (amountBalance != beast::kZero || amount2Balance != beast::kZero)
        {
            // LCOV_EXCL_START
            JLOG(ctx.j.debug()) << "AMM Deposit: tokens balance is not zero.";
            return tecINTERNAL;
            // LCOV_EXCL_STOP
        }
    }
    else
    {
        if (lptAMMBalance == beast::kZero)
            return tecAMM_EMPTY;
        if (amountBalance <= beast::kZero || amount2Balance <= beast::kZero ||
            lptAMMBalance < beast::kZero)
        {
            // LCOV_EXCL_START
            JLOG(ctx.j.debug()) << "AMM Deposit: reserves or tokens balance is zero.";
            return tecINTERNAL;
            // LCOV_EXCL_STOP
        }
    }
 
    // Check account has sufficient funds.
    // Return tesSUCCESS if it does,  error otherwise.
    // Have to check again in deposit() because
    // amounts might be derived based on tokens or
    // limits.
    auto balance = [&](auto const& deposit) -> TER {
        if (isXRP(deposit))
        {
            auto const lpIssue = (*ammSle)[sfLPTokenBalance].get<Issue>();
            // Adjust the reserve if LP doesn't have LPToken trustline
            auto const sle =
                ctx.view.read(keylet::trustLine(accountID, lpIssue.account, lpIssue.currency));
            if (xrpLiquid(ctx.view, accountID, !sle, ctx.j) >= deposit)
                return TER(tesSUCCESS);
            if (sle)
                return tecUNFUNDED_AMM;
            return tecINSUF_RESERVE_LINE;
        }
        return accountFunds(
                   ctx.view,
                   accountID,
                   deposit,
                   FreezeHandling::IgnoreFreeze,
                   AuthHandling::IgnoreAuth,
                   ctx.j) >= deposit
            ? TER(tesSUCCESS)
            : tecUNFUNDED_AMM;
    };
 
    auto const amount = ctx.tx[~sfAmount];
    auto const amount2 = ctx.tx[~sfAmount2];
    auto const ammAccountID = ammSle->getAccountID(sfAccount);
 
    if (ctx.view.rules().enabled(fixCleanup3_3_0))
    {
        // Unified deposit freeze check for both pool assets.
        // AMMDeposit is not allowed if either asset is frozen.
        auto checkAsset = [&](Asset const& asset) -> TER {
            if (auto const ter = requireAuth(ctx.view, asset, accountID, AuthType::WeakAuth))
            {
                JLOG(ctx.j.debug()) << "AMM Deposit: account is not authorized, " << asset;
                return ter;
            }
            if (auto const ter = checkDepositFreeze(ctx.view, accountID, ammAccountID, asset))
            {
                JLOG(ctx.j.debug())
                    << "AMM Deposit: frozen, " << to_string(accountID) << " " << to_string(asset);
                return ter;
            }
            return tesSUCCESS;
        };
 
        if (auto const ter = checkAsset(ctx.tx[sfAsset]))
            return ter;
 
        if (auto const ter = checkAsset(ctx.tx[sfAsset2]))
            return ter;
    }
    else if (ctx.view.rules().enabled(featureAMMClawback))
    {
        // Check if either of the assets is frozen, AMMDeposit is not allowed
        // if either asset is frozen
        auto checkAsset = [&](Asset const& asset) -> TER {
            // WeakAuth - don't need to check if MPT object exists as might be
            // depositing into non-MPT pool. It'll fail on send if MPT doesn't
            // exist.
            if (auto const ter = requireAuth(ctx.view, asset, accountID, AuthType::WeakAuth))
            {
                JLOG(ctx.j.debug()) << "AMM Deposit: account is not authorized, " << asset;
                return ter;
            }
 
            if (auto const ter = checkFrozen(ctx.view, accountID, asset); !isTesSuccess(ter))
            {
                JLOG(ctx.j.debug()) << "AMM Deposit: account or currency is frozen or locked, "
                                    << to_string(accountID) << " " << to_string(asset);
 
                return ter;
            }
 
            return tesSUCCESS;
        };
 
        if (auto const ter = checkAsset(ctx.tx[sfAsset]))
            return ter;
 
        if (auto const ter = checkAsset(ctx.tx[sfAsset2]))
            return ter;
    }
 
    auto checkAmount = [&](std::optional<STAmount> const& amount, bool checkBalance) -> TER {
        if (amount)
        {
            // This normally should not happen.
            // Account is not authorized to hold the assets it's depositing,
            // or it doesn't even have a trust line or MPT for them.
            if (auto const ter = requireAuth(ctx.view, amount->asset(), accountID))
            {
                // LCOV_EXCL_START
                JLOG(ctx.j.debug())
                    << "AMM Deposit: account is not authorized, " << amount->asset();
                return ter;
                // LCOV_EXCL_STOP
            }
            if (!ctx.view.rules().enabled(fixCleanup3_3_0))
            {
                // AMM account or currency frozen
                if (auto const ter = checkFrozen(ctx.view, ammAccountID, amount->asset());
                    !isTesSuccess(ter))
                {
                    JLOG(ctx.j.debug())
                        << "AMM Deposit: AMM account or currency is frozen or locked, "
                        << to_string(accountID);
                    return ter;
                }
                // Account frozen
                if (auto const ter = checkIndividualFrozen(ctx.view, accountID, amount->asset());
                    !isTesSuccess(ter))
                {
                    JLOG(ctx.j.debug())
                        << "AMM Deposit: account is frozen or locked, " << to_string(accountID)
                        << " " << to_string(amount->asset());
                    return ter;
                }
            }
            if (checkBalance)
            {
                if (auto const ter = balance(*amount))
                {
                    JLOG(ctx.j.debug())
                        << "AMM Deposit: account has insufficient funds, " << *amount;
                    return ter;
                }
            }
        }
        return tesSUCCESS;
    };
 
    // amount and amount2 are deposit min in case of tfLPToken
    if (!ctx.tx.isFlag(tfLPToken))
    {
        if (auto const ter = checkAmount(amount, true))
            return ter;
 
        if (auto const ter = checkAmount(amount2, true))
            return ter;
    }
    else
    {
        if (auto const ter = checkAmount(amountBalance, false))
            return ter;
        if (auto const ter = checkAmount(amount2Balance, false))
            return ter;
    }
 
    // Equal deposit lp tokens
    if (auto const lpTokens = ctx.tx[~sfLPTokenOut];
        lpTokens && lpTokens->asset() != lptAMMBalance.asset())
    {
        JLOG(ctx.j.debug()) << "AMM Deposit: invalid LPTokens.";
        return temBAD_AMM_TOKENS;
    }
 
    // Check the reserve for LPToken trustline if not LP.
    // We checked above but need to check again if depositing IOU only.
    if (ammLPHolds(ctx.view, *ammSle, accountID, ctx.j) == beast::kZero)
    {
        STAmount const xrpBalance = xrpLiquid(ctx.view, accountID, 1, ctx.j);
        // Insufficient reserve
        if (xrpBalance <= beast::kZero)
        {
            JLOG(ctx.j.debug()) << "AMM Instance: insufficient reserves";
            return tecINSUF_RESERVE_LINE;
        }
    }
 
    if (auto const ter = canMPTTradeAndTransfer(ctx.view, ctx.tx[sfAsset], accountID, accountID);
        !isTesSuccess(ter))
        return ter;
    if (auto const ter = canMPTTradeAndTransfer(ctx.view, ctx.tx[sfAsset2], accountID, accountID);
        !isTesSuccess(ter))
        return ter;
 
    return tesSUCCESS;
}
 
std::pair<TER, bool>
AMMDeposit::applyGuts(Sandbox& sb)
{
    auto const amount = ctx_.tx[~sfAmount];
    auto const amount2 = ctx_.tx[~sfAmount2];
    auto const ePrice = ctx_.tx[~sfEPrice];
    auto const lpTokensDeposit = ctx_.tx[~sfLPTokenOut];
    auto ammSle = sb.peek(keylet::amm(ctx_.tx[sfAsset], ctx_.tx[sfAsset2]));
    if (!ammSle)
        return {tecINTERNAL, false};  // LCOV_EXCL_LINE
    auto const ammAccountID = (*ammSle)[sfAccount];
 
    auto const expected = ammHolds(
        sb,
        *ammSle,
        amount ? amount->asset() : std::optional<Asset>{},
        amount2 ? amount2->asset() : std::optional<Asset>{},
        FreezeHandling::ZeroIfFrozen,
        AuthHandling::ZeroIfUnauthorized,
        ctx_.journal);
    if (!expected)
        return {expected.error(), false};  // LCOV_EXCL_LINE
    auto const [amountBalance, amount2Balance, lptAMMBalance] = *expected;
    auto const tfee = (lptAMMBalance == beast::kZero)
        ? ctx_.tx[~sfTradingFee].value_or(0)
        : getTradingFee(ctx_.view(), *ammSle, accountID_);
 
    auto const subTxType = ctx_.tx.getFlags() & tfDepositSubTx;
 
    auto dispatchToDeposit = [&,
                              &amountBalance = amountBalance,
                              &amount2Balance = amount2Balance,
                              &lptAMMBalance = lptAMMBalance]() -> std::pair<TER, STAmount> {
        if (subTxType & tfTwoAsset)
        {
            return equalDepositLimit(
                sb,
                ammAccountID,
                amountBalance,
                amount2Balance,
                lptAMMBalance,
                *amount,
                *amount2,
                lpTokensDeposit,
                tfee);
        }
        if (subTxType & tfOneAssetLPToken)
        {
            return singleDepositTokens(
                sb, ammAccountID, amountBalance, *amount, lptAMMBalance, *lpTokensDeposit, tfee);
        }
        if (subTxType & tfLimitLPToken)
        {
            return singleDepositEPrice(
                sb, ammAccountID, amountBalance, *amount, lptAMMBalance, *ePrice, tfee);
        }
        if (subTxType & tfSingleAsset)
        {
            return singleDeposit(
                sb, ammAccountID, amountBalance, lptAMMBalance, *amount, lpTokensDeposit, tfee);
        }
        if (subTxType & tfLPToken)
        {
            return equalDepositTokens(
                sb,
                ammAccountID,
                amountBalance,
                amount2Balance,
                lptAMMBalance,
                *lpTokensDeposit,
                amount,
                amount2,
                tfee);
        }
        if (subTxType & tfTwoAssetIfEmpty)
        {
            return equalDepositInEmptyState(
                sb, ammAccountID, *amount, *amount2, lptAMMBalance.asset(), tfee);
        }
        // should not happen.
        // LCOV_EXCL_START
        JLOG(j_.error()) << "AMM Deposit: invalid options.";
        return std::make_pair(tecINTERNAL, STAmount{});
        // LCOV_EXCL_STOP
    };
 
    auto const [result, newLPTokenBalance] = [&]() -> std::pair<TER, STAmount> {
        try
        {
            return dispatchToDeposit();
        }
        catch (std::runtime_error const& e)
        {
            REACHABLE("xrpl::AMMDeposit::applyGuts : deposit amount out of range reached");
            // A deposit whose solved amount exceeds the integral asset's range
            // throws while converting to STAmount: past int64max
            // Number::operator rep() throws std::overflow_error; above the asset
            // maximum STAmount::canonicalize throws std::runtime_error. Fail
            // cleanly with a tec rather than letting it escape doApply as
            // tefEXCEPTION. Any other exception is left to propagate.
            // Gated by fixCleanup3_4_0 to preserve the legacy result pre-amendment.
            if (!sb.rules().enabled(fixCleanup3_4_0))
                throw;  // LCOV_EXCL_LINE - preserve legacy tefEXCEPTION
            JLOG(j_.error()) << "AMMDeposit: deposit amount out of range " << e.what();
            return std::make_pair(tecAMM_FAILED, STAmount{});
        }
    }();
 
    if (isTesSuccess(result))
    {
        XRPL_ASSERT(
            newLPTokenBalance > beast::kZero,
            "xrpl::AMMDeposit::applyGuts : valid new LP token balance");
        // Defensive check: deposit formulas with fixAMMv1_3 round LP tokens
        // down and asset amounts up, so sqrt(pool1*pool2) >= newLPTokenBalance
        // is guaranteed to hold. A precision loss failure is not expected.
        if (sb.rules().enabled(fixCleanup3_3_0) && sb.rules().enabled(fixAMMv1_3))
        {
            if (auto const ter = checkAMMPrecisionLoss(
                    sb, ammAccountID, ctx_.tx[sfAsset], ctx_.tx[sfAsset2], newLPTokenBalance, j_);
                !isTesSuccess(ter))
            {
                UNREACHABLE("xrpl::AMMDeposit::applyGuts : AMM precision loss");
                return {ter, false};  // LCOV_EXCL_LINE
            }
        }
        ammSle->setFieldAmount(sfLPTokenBalance, newLPTokenBalance);
        // LP depositing into AMM empty state gets the auction slot
        // and the voting
        if (lptAMMBalance == beast::kZero)
            initializeFeeAuctionVote(sb, ammSle, accountID_, lptAMMBalance.asset(), tfee);
 
        sb.update(ammSle);
    }
 
    return {result, isTesSuccess(result)};
}
 
TER
AMMDeposit::doApply()
{
    // This is the ledger view that we work against. Transactions are applied
    // as we go on processing transactions.
    Sandbox sb(&ctx_.view());
 
    auto const result = applyGuts(sb);
    if (result.second)
        sb.apply(ctx_.rawView());
 
    return result.first;
}
 
std::pair<TER, STAmount>
AMMDeposit::deposit(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amountBalance,
    STAmount const& amountDeposit,
    std::optional<STAmount> const& amount2Deposit,
    STAmount const& lptAMMBalance,
    STAmount const& lpTokensDeposit,
    std::optional<STAmount> const& depositMin,
    std::optional<STAmount> const& deposit2Min,
    std::optional<STAmount> const& lpTokensDepositMin,
    std::uint16_t tfee)
{
    // Check account has sufficient funds.
    // Return true if it does, false otherwise.
    auto checkBalance = [&](auto const& depositAmount) -> TER {
        if (depositAmount <= beast::kZero)
            return temBAD_AMOUNT;
        if (isXRP(depositAmount))
        {
            auto const& lpIssue = lpTokensDeposit.get<Issue>();
            // Adjust the reserve if LP doesn't have LPToken trustline
            auto const sle =
                view.read(keylet::trustLine(accountID_, lpIssue.account, lpIssue.currency));
            if (xrpLiquid(view, accountID_, !sle, j_) >= depositAmount)
                return tesSUCCESS;
        }
        else if (
            accountFunds(
                view,
                accountID_,
                depositAmount,
                FreezeHandling::IgnoreFreeze,
                AuthHandling::IgnoreAuth,
                ctx_.journal) >= depositAmount)
        {
            return tesSUCCESS;
        }
        return tecUNFUNDED_AMM;
    };
 
    auto const [amountDepositActual, amount2DepositActual, lpTokensDepositActual] =
        adjustAmountsByLPTokens(
            amountBalance,
            amountDeposit,
            amount2Deposit,
            lptAMMBalance,
            lpTokensDeposit,
            tfee,
            IsDeposit::Yes);
 
    if (lpTokensDepositActual <= beast::kZero)
    {
        JLOG(ctx_.journal.debug()) << "AMM Deposit: adjusted tokens zero";
        return {tecAMM_INVALID_TOKENS, STAmount{}};
    }
 
    if (amountDepositActual < depositMin || amount2DepositActual < deposit2Min ||
        lpTokensDepositActual < lpTokensDepositMin)
    {
        JLOG(ctx_.journal.debug())
            << "AMM Deposit: min deposit fails " << amountDepositActual << " "
            << depositMin.value_or(STAmount{}) << " " << amount2DepositActual.value_or(STAmount{})
            << " " << deposit2Min.value_or(STAmount{}) << " " << lpTokensDepositActual << " "
            << lpTokensDepositMin.value_or(STAmount{});
        return {tecAMM_FAILED, STAmount{}};
    }
 
    // Deposit amountDeposit
    if (auto const ter = checkBalance(amountDepositActual))
    {
        JLOG(ctx_.journal.debug()) << "AMM Deposit: account has insufficient "
                                      "checkBalance to deposit or is 0"
                                   << amountDepositActual;
        return {ter, STAmount{}};
    }
 
    auto res = accountSend(
        view,
        accountID_,
        ammAccount,
        amountDepositActual,
        ctx_.journal,
        {},  // don't sponsor for AMM Trustline
        WaiveTransferFee::Yes);
    if (!isTesSuccess(res))
    {
        JLOG(ctx_.journal.debug()) << "AMM Deposit: failed to deposit " << amountDepositActual;
        return {res, STAmount{}};
    }
 
    // Deposit amount2Deposit
    if (amount2DepositActual)
    {
        if (auto const ter = checkBalance(*amount2DepositActual))
        {
            JLOG(ctx_.journal.debug()) << "AMM Deposit: account has insufficient checkBalance to "
                                          "deposit or is 0 "
                                       << *amount2DepositActual;
            return {ter, STAmount{}};
        }
 
        res = accountSend(
            view,
            accountID_,
            ammAccount,
            *amount2DepositActual,
            ctx_.journal,
            {},  // don't sponsor for AMM Trustline
            WaiveTransferFee::Yes);
        if (!isTesSuccess(res))
        {
            JLOG(ctx_.journal.debug())
                << "AMM Deposit: failed to deposit " << *amount2DepositActual;
            return {res, STAmount{}};
        }
    }
 
    // Deposit LP tokens
    res = accountSend(view, ammAccount, accountID_, lpTokensDepositActual, ctx_.journal);
    if (!isTesSuccess(res))
    {
        JLOG(ctx_.journal.debug()) << "AMM Deposit: failed to deposit LPTokens";
        return {res, STAmount{}};
    }
 
    return {tesSUCCESS, lptAMMBalance + lpTokensDepositActual};
}
 
static STAmount
adjustLPTokensOut(
    Rules const& rules,
    STAmount const& lptAMMBalance,
    STAmount const& lpTokensDeposit)
{
    if (!rules.enabled(fixAMMv1_3))
        return lpTokensDeposit;
    return adjustLPTokens(lptAMMBalance, lpTokensDeposit, IsDeposit::Yes);
}

std::pair<TER, STAmount>
AMMDeposit::equalDepositTokens(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amountBalance,
    STAmount const& amount2Balance,
    STAmount const& lptAMMBalance,
    STAmount const& lpTokensDeposit,
    std::optional<STAmount> const& depositMin,
    std::optional<STAmount> const& deposit2Min,
    std::uint16_t tfee)
{
    try
    {
        auto const tokensAdj = adjustLPTokensOut(view.rules(), lptAMMBalance, lpTokensDeposit);
        if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero)
            return {tecAMM_INVALID_TOKENS, STAmount{}};
        auto const frac = divide(tokensAdj, lptAMMBalance, lptAMMBalance.asset());
        // amounts factor in the adjusted tokens
        auto const amountDeposit =
            getRoundedAsset(view.rules(), amountBalance, frac, IsDeposit::Yes);
        auto const amount2Deposit =
            getRoundedAsset(view.rules(), amount2Balance, frac, IsDeposit::Yes);
        return deposit(
            view,
            ammAccount,
            amountBalance,
            amountDeposit,
            amount2Deposit,
            lptAMMBalance,
            tokensAdj,
            depositMin,
            deposit2Min,
            std::nullopt,
            tfee);
    }
    catch (std::exception const& e)
    {
        // LCOV_EXCL_START
        JLOG(j_.error()) << "AMMDeposit::equalDepositTokens exception " << e.what();
        return {tecINTERNAL, STAmount{}};
        // LCOV_EXCL_STOP
    }
}

std::pair<TER, STAmount>
AMMDeposit::equalDepositLimit(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amountBalance,
    STAmount const& amount2Balance,
    STAmount const& lptAMMBalance,
    STAmount const& amount,
    STAmount const& amount2,
    std::optional<STAmount> const& lpTokensDepositMin,
    std::uint16_t tfee)
{
    auto frac = Number{amount} / amountBalance;
    auto tokensAdj = getRoundedLPTokens(view.rules(), lptAMMBalance, frac, IsDeposit::Yes);
    if (tokensAdj == beast::kZero)
    {
        if (!view.rules().enabled(fixAMMv1_3))
        {
            return {tecAMM_FAILED, STAmount{}};  // LCOV_EXCL_LINE
        }
 
        return {tecAMM_INVALID_TOKENS, STAmount{}};
    }
    // factor in the adjusted tokens
    frac = adjustFracByTokens(view.rules(), lptAMMBalance, tokensAdj, frac);
    auto const amount2Deposit = getRoundedAsset(view.rules(), amount2Balance, frac, IsDeposit::Yes);
    if (amount2Deposit <= amount2)
    {
        return deposit(
            view,
            ammAccount,
            amountBalance,
            amount,
            amount2Deposit,
            lptAMMBalance,
            tokensAdj,
            std::nullopt,
            std::nullopt,
            lpTokensDepositMin,
            tfee);
    }
    frac = Number{amount2} / amount2Balance;
    tokensAdj = getRoundedLPTokens(view.rules(), lptAMMBalance, frac, IsDeposit::Yes);
    if (tokensAdj == beast::kZero)
    {
        if (!view.rules().enabled(fixAMMv1_3))
        {
            return {tecAMM_FAILED, STAmount{}};  // LCOV_EXCL_LINE
        }
 
        return {tecAMM_INVALID_TOKENS, STAmount{}};  // LCOV_EXCL_LINE
    }
    // factor in the adjusted tokens
    frac = adjustFracByTokens(view.rules(), lptAMMBalance, tokensAdj, frac);
    auto const amountDeposit = getRoundedAsset(view.rules(), amountBalance, frac, IsDeposit::Yes);
    if (amountDeposit <= amount)
    {
        return deposit(
            view,
            ammAccount,
            amountBalance,
            amountDeposit,
            amount2,
            lptAMMBalance,
            tokensAdj,
            std::nullopt,
            std::nullopt,
            lpTokensDepositMin,
            tfee);
    }
    return {tecAMM_FAILED, STAmount{}};
}

std::pair<TER, STAmount>
AMMDeposit::singleDeposit(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amountBalance,
    STAmount const& lptAMMBalance,
    STAmount const& amount,
    std::optional<STAmount> const& lpTokensDepositMin,
    std::uint16_t tfee)
{
    auto const tokens = adjustLPTokensOut(
        view.rules(), lptAMMBalance, lpTokensOut(amountBalance, amount, lptAMMBalance, tfee));
    if (tokens == beast::kZero)
    {
        if (!view.rules().enabled(fixAMMv1_3))
        {
            return {tecAMM_FAILED, STAmount{}};  // LCOV_EXCL_LINE
        }
 
        return {tecAMM_INVALID_TOKENS, STAmount{}};
    }
    // factor in the adjusted tokens
    auto const [tokensAdj, amountDepositAdj] =
        adjustAssetInByTokens(view.rules(), amountBalance, amount, lptAMMBalance, tokens, tfee);
    if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero)
        return {tecAMM_INVALID_TOKENS, STAmount{}};  // LCOV_EXCL_LINE
    return deposit(
        view,
        ammAccount,
        amountBalance,
        amountDepositAdj,
        std::nullopt,
        lptAMMBalance,
        tokensAdj,
        std::nullopt,
        std::nullopt,
        lpTokensDepositMin,
        tfee);
}

std::pair<TER, STAmount>
AMMDeposit::singleDepositTokens(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amountBalance,
    STAmount const& amount,
    STAmount const& lptAMMBalance,
    STAmount const& lpTokensDeposit,
    std::uint16_t tfee)
{
    auto const tokensAdj = adjustLPTokensOut(view.rules(), lptAMMBalance, lpTokensDeposit);
    if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero)
        return {tecAMM_INVALID_TOKENS, STAmount{}};
    // the adjusted tokens are factored in
    auto const amountDeposit = ammAssetIn(amountBalance, lptAMMBalance, tokensAdj, tfee);
    if (amountDeposit > amount)
        return {tecAMM_FAILED, STAmount{}};
    return deposit(
        view,
        ammAccount,
        amountBalance,
        amountDeposit,
        std::nullopt,
        lptAMMBalance,
        tokensAdj,
        std::nullopt,
        std::nullopt,
        std::nullopt,
        tfee);
}

std::pair<TER, STAmount>
AMMDeposit::singleDepositEPrice(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amountBalance,
    STAmount const& amount,
    STAmount const& lptAMMBalance,
    STAmount const& ePrice,
    std::uint16_t tfee)
{
    if (amount != beast::kZero)
    {
        auto const tokens = adjustLPTokensOut(
            view.rules(), lptAMMBalance, lpTokensOut(amountBalance, amount, lptAMMBalance, tfee));
        if (tokens <= beast::kZero)
        {
            if (!view.rules().enabled(fixAMMv1_3))
            {
                return {tecAMM_FAILED, STAmount{}};  // LCOV_EXCL_LINE
            }
 
            return {tecAMM_INVALID_TOKENS, STAmount{}};
        }
        // factor in the adjusted tokens
        auto const [tokensAdj, amountDepositAdj] =
            adjustAssetInByTokens(view.rules(), amountBalance, amount, lptAMMBalance, tokens, tfee);
        if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero)
            return {tecAMM_INVALID_TOKENS, STAmount{}};  // LCOV_EXCL_LINE
        auto const ep = Number{amountDepositAdj} / tokensAdj;
        if (ep <= ePrice)
        {
            return deposit(
                view,
                ammAccount,
                amountBalance,
                amountDepositAdj,
                std::nullopt,
                lptAMMBalance,
                tokensAdj,
                std::nullopt,
                std::nullopt,
                std::nullopt,
                tfee);
        }
    }
 
    // LPTokens is asset out => E = b / t
    // substituting t in formula (3) as b/E:
    // b/E = T * [b/B - sqrt(t2**2 + b/(f1*B)) + t2]/
    //                      [1 + sqrt(t2**2 + b/(f1*B)) -t2] (A)
    // where f1 = 1 - fee, f2 = (1 - fee/2)/f1
    // Let R = b/(f1*B), then b/B = f1*R and b = R*f1*B
    // Then (A) is
    // R*f1*B = E*T*[R*f1 -sqrt(f2**2 + R) + f2]/[1 + sqrt(f2**2 + R) - f2] =>
    // Let c = f1*B/(E*T) =>
    // R*c*(1 + sqrt(f2**2 + R) + f2) = R*f1 - sqrt(f2**2 + R) - f2 =>
    // (R*c + 1)*sqrt(f2**2 + R) = R*(f1 + c*f2 - c) + f2 =>
    // Let d = f1 + c*f2 - c =>
    // (R*c + 1)*sqrt(f2**2 + R) = R*d + f2 =>
    // (R*c + 1)**2 * (f2**2 + R) = (R*d + f2)**2 =>
    // (R*c)**2 + R*((c*f2)**2 + 2*c - d**2) + 2*c*f2**2 + 1 -2*d*f2 = 0 =>
    // a1 = c**2, b1 = (c*f2)**2 + 2*c - d**2, c1 = 2*c*f2**2 + 1 - 2*d*f2
    // R = (-b1 + sqrt(b1**2 + 4*a1*c1))/(2*a1)
    auto const f1 = feeMult(tfee);
    auto const f2 = feeMultHalf(tfee) / f1;
    auto const c = f1 * amountBalance / (ePrice * lptAMMBalance);
    auto const d = f1 + c * f2 - c;
    auto const a1 = c * c;
    auto const b1 = c * c * f2 * f2 + 2 * c - d * d;
    auto const c1 = 2 * c * f2 * f2 + 1 - 2 * d * f2;
    auto amtNoRoundCb = [&] { return f1 * amountBalance * solveQuadraticEq(a1, b1, c1); };
    auto amtProdCb = [&] { return f1 * solveQuadraticEq(a1, b1, c1); };
    auto const amountDeposit =
        getRoundedAsset(view.rules(), amtNoRoundCb, amountBalance, amtProdCb, IsDeposit::Yes);
    if (amountDeposit <= beast::kZero)
        return {tecAMM_FAILED, STAmount{}};
    auto tokNoRoundCb = [&] { return amountDeposit / ePrice; };
    auto tokProdCb = [&] { return amountDeposit / ePrice; };
    auto const tokens =
        getRoundedLPTokens(view.rules(), tokNoRoundCb, lptAMMBalance, tokProdCb, IsDeposit::Yes);
    // factor in the adjusted tokens
    auto const [tokensAdj, amountDepositAdj] = adjustAssetInByTokens(
        view.rules(), amountBalance, amountDeposit, lptAMMBalance, tokens, tfee);
    if (view.rules().enabled(fixAMMv1_3) && tokensAdj == beast::kZero)
        return {tecAMM_INVALID_TOKENS, STAmount{}};  // LCOV_EXCL_LINE
 
    return deposit(
        view,
        ammAccount,
        amountBalance,
        amountDepositAdj,
        std::nullopt,
        lptAMMBalance,
        tokensAdj,
        std::nullopt,
        std::nullopt,
        std::nullopt,
        tfee);
}
 
std::pair<TER, STAmount>
AMMDeposit::equalDepositInEmptyState(
    Sandbox& view,
    AccountID const& ammAccount,
    STAmount const& amount,
    STAmount const& amount2,
    Asset const& lptIssue,
    std::uint16_t tfee)
{
    return deposit(
        view,
        ammAccount,
        amount,
        amount,
        amount2,
        STAmount{lptIssue, 0},
        ammLPTokens(amount, amount2, lptIssue),
        std::nullopt,
        std::nullopt,
        std::nullopt,
        tfee);
}
 
void
AMMDeposit::visitInvariantEntry(bool, SLE::const_ref, SLE::const_ref)
{
    // No transaction-specific invariants yet (future work).
}
 
bool
AMMDeposit::finalizeInvariants(STTx const&, TER, XRPAmount, ReadView const&, beast::Journal const&)
{
    // No transaction-specific invariants yet (future work).
    return true;
}
 
}  // namespace xrpl