AMMOffer.h

#pragma once
 
#include <xrpl/basics/base_uint.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/ledger/ApplyView.h>
#include <xrpl/ledger/helpers/TokenHelpers.h>
#include <xrpl/protocol/AccountID.h>
#include <xrpl/protocol/Concepts.h>
#include <xrpl/protocol/Quality.h>
#include <xrpl/protocol/STLedgerEntry.h>
#include <xrpl/protocol/TER.h>
 
#include <cstdint>
#include <optional>
#include <utility>
 
namespace xrpl {
 
template <typename TIn, typename TOut>
class AMMLiquidity;
class QualityFunction;

template <StepAmount TIn, StepAmount TOut>
class AMMOffer
{
private:
    AMMLiquidity<TIn, TOut> const& ammLiquidity_;
    // Initial offer amounts. It is fibonacci seq generated for multi-path.
    // If the offer size is set based on the competing CLOB offer then
    // the AMM offer size is such that if the offer is consumed then
    // the updated AMM pool SP quality is going to be equal to competing
    // CLOB offer quality. If there is no competing CLOB offer then
    // the initial size is set to in=cMax[Native,Value],balances.out.
    // While this is not a "real" offer it simulates the case of
    // the swap out of the entire side of the pool, in which case
    // the swap in amount is infinite.
    TAmounts<TIn, TOut> const amounts_;
    // Current pool balances.
    TAmounts<TIn, TOut> const balances_;
    // The Spot Price quality if balances != amounts
    // else the amounts quality
    Quality const quality_;
    // AMM offer can be consumed once at a given iteration
    bool consumed_{false};
 
public:
    AMMOffer(
        AMMLiquidity<TIn, TOut> const& ammLiquidity,
        TAmounts<TIn, TOut> const& amounts,
        TAmounts<TIn, TOut> const& balances,
        Quality const& quality);
 
    [[nodiscard]] Quality
    quality() const noexcept
    {
        return quality_;
    }
 
    [[nodiscard]] Asset const&
    assetIn() const;
 
    [[nodiscard]] Asset const&
    assetOut() const;
 
    [[nodiscard]] AccountID const&
    owner() const;
 
    [[nodiscard]] std::optional<uint256>
    key() const
    {
        return std::nullopt;
    }
 
    [[nodiscard]] TAmounts<TIn, TOut> const&
    amount() const;
 
    void
    consume(ApplyView& view, TAmounts<TIn, TOut> const& consumed);
 
    [[nodiscard]] bool
    fullyConsumed() const
    {
        return consumed_;
    }

    [[nodiscard]] TAmounts<TIn, TOut>
    limitOut(TAmounts<TIn, TOut> const& offerAmount, TOut const& limit, bool roundUp) const;

    [[nodiscard]] TAmounts<TIn, TOut>
    limitIn(TAmounts<TIn, TOut> const& offerAmount, TIn const& limit, bool roundUp) const;
 
    [[nodiscard]] QualityFunction
    getQualityFunc() const;

    template <typename... Args>
    static TER
    send(Args&&... args)
    {
        return accountSend(
            std::forward<Args>(args)...,
            SLE::pointer(),
            WaiveTransferFee::Yes,
            AllowMPTOverflow::Yes);
    }
 
    [[nodiscard]] bool
    isFunded() const
    {
        // AMM offer is fully funded by the pool
        return true;
    }
 
    static std::pair<std::uint32_t, std::uint32_t>
    adjustRates(std::uint32_t ofrInRate, std::uint32_t ofrOutRate)
    {
        // AMM doesn't pay transfer fee on Payment tx
        return {ofrInRate, QUALITY_ONE};
    }

    [[nodiscard]] bool
    checkInvariant(TAmounts<TIn, TOut> const& consumed, beast::Journal j) const;
};
 
}  // namespace xrpl