traits.hpp

#pragma once

#define ATL_BROKER_ADAPTER_PRESENT 1
 
#include "./client.hpp"
 
#include "../../core/broker_session.hpp"
#include "../../core/broker_traits.hpp"
 
#include <cstdint>
#include <optional>
#include <string>
#include <utility>
 
namespace algotradelib {
 
namespace tossinvest {

struct Broker {
  static constexpr std::string_view name = "tossinvest";
};
 
namespace traits_detail {

using Ref = OrderRef<tossinvest::Broker>;

struct Normalizers {
  static constexpr bool has_depth = true;

  static constexpr bool has_price_limits = true;

  static constexpr bool has_trade_prints = true;

  static constexpr bool has_batch_prices = true;

  static constexpr bool has_buying_power = true;

  static constexpr bool has_buying_power_quantity = false;

  static constexpr SellableSource sellable_source = SellableSource::INQUIRY;

  static constexpr SellableBasis sellable_inquiry_basis{
    SellableBasis::Coverage::WHOLE_HOLDING,
    SellableBasis::RestingTreatment::DEDUCT,
    false,
  };

  static constexpr bool has_commission_schedule = true;

  static constexpr bool has_reference_data = true;

  static constexpr bool has_batch_reference_data = true;

  static constexpr bool has_calendar = true;

  static constexpr bool has_calendar_range = false;

  static constexpr bool has_calendar_sessions = true;

  static std::optional<BrokerError> validate_calendar(Country, std::optional<Date> from) {
    if (!from || is_valid_date(*from)) {
      return std::nullopt;
    }
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    error.broker_code_ = "invalid_date";
    error.message_ = "calendar request requires a valid Gregorian date";
    return error;
  }

  static constexpr bool supports_interval(BarInterval interval) {
    static_cast<void>(interval);
    return interval == BarInterval::ONE_MINUTE || interval == BarInterval::ONE_DAY;
  }

  static std::optional<BrokerError> validate_bars(const BarQuery& query) {
    return tossinvest::unsupported_bar_interval(query.interval_);
  }

  static Ref make_ref(std::string order_id) {
    Ref ref;
    ref.primary_ = std::move(order_id);
    return ref;
  }

  static std::optional<BrokerError> validate_place(const OrderRequest&) { return std::nullopt; }

  static Result<PlacedOrder<tossinvest::Broker>> normalize_place(Result<OrderAck> raw) {
    if (!raw) {
      return Result<PlacedOrder<tossinvest::Broker>>(std::move(raw.error()));
    }
    PlacedOrder<tossinvest::Broker> placed;
    placed.ref_ = make_ref(raw.value().order_id_);
    placed.ack_ = std::move(raw.value());
    return Result<PlacedOrder<tossinvest::Broker>>(std::move(placed));
  }

  static Result<WorkingOrders<tossinvest::Broker>> normalize_working_orders(
    Result<OrderPage> raw
  ) {
    if (!raw) {
      return Result<WorkingOrders<tossinvest::Broker>>(std::move(raw.error()));
    }
    WorkingOrders<tossinvest::Broker> orders;
    orders.received_at_ = raw.value().received_at_;
    orders.orders_.reserve(raw.value().orders_.size());
    for (auto& order : raw.value().orders_) {
      WorkingOrder<tossinvest::Broker> working;
      working.ref_ = make_ref(order.order_id_);
      working.order_ = std::move(order);
      orders.orders_.push_back(std::move(working));
    }
    return Result<WorkingOrders<tossinvest::Broker>>(std::move(orders));
  }

  static Result<tossinvest::TossAmendment> to_replacement(
    const Ref& ref,
    const AmendInstruction& instruction
  ) {
    // Toss's `OrderModifyRequest` carries `orderType`, `quantity`, `price` and
    // the high-value flag, and **no validity field at all**: a modification
    // cannot change the condition or the session, and Toss cannot refuse a
    // request to. So this refuses on Toss's behalf, and the question is not
    // whether the requested value is one Toss supports -- it can place a
    // closing-auction order -- but whether it *differs* from what the order
    // already is.
    //
    // Which means the original has to be known. An unset `resting_` is refused
    // rather than assumed to match: a hand-built instruction naming DAY/REGULAR
    // against a resting CLS order compared equal to a defaulted original and was
    // sent, and the order stayed CLS while the caller was told it had moved.
    if (!instruction.resting_) {
      BrokerError error;
      error.category_ = ErrorCategory::INVALID_ARGUMENT;
      error.reached_broker_ = false;
      error.broker_code_ = "unknown_resting_shape";
      error.message_ =
        "Toss cannot change an order's validity condition or session by amending it, and this "
        "instruction does not say what the order's are, so neither can be verified; build the "
        "instruction with reprice() or replace_with() from the working order";
      return Result<tossinvest::TossAmendment>(std::move(error));
    }
    // An unset field on the shape asks for no change, which is always safe here.
    if (instruction.shape_.time_in_force_ &&
        *instruction.shape_.time_in_force_ != instruction.resting_->time_in_force_) {
      BrokerError error;
      error.category_ = ErrorCategory::INVALID_ARGUMENT;
      error.reached_broker_ = false;
      error.broker_code_ = "unsupported_time_in_force";
      error.message_ =
        "Toss cannot change an order's validity condition by amending it; cancel the order and "
        "place a new one instead";
      return Result<tossinvest::TossAmendment>(std::move(error));
    }
    if (instruction.shape_.session_ &&
        *instruction.shape_.session_ != instruction.resting_->session_) {
      BrokerError error;
      error.category_ = ErrorCategory::INVALID_ARGUMENT;
      error.reached_broker_ = false;
      error.broker_code_ = "unsupported_session";
      error.message_ =
        "Toss cannot move an order to another trading session by amending it; cancel the order "
        "and place a new one instead";
      return Result<tossinvest::TossAmendment>(std::move(error));
    }
 
    tossinvest::TossAmendment amendment;
    amendment.order_id_ = ref.primary_;
    amendment.type_ = instruction.shape_.type_;
    amendment.quantity_ = instruction.quantity_;
    amendment.price_ = instruction.shape_.price_;
    amendment.confirm_high_value_ = instruction.confirm_high_value_;
    return Result<tossinvest::TossAmendment>(std::move(amendment));
  }

  static Result<tossinvest::TossAmendment> to_cancellation(
    const Ref& ref,
    const AmendInstruction& instruction
  ) {
    if (!instruction.all_remaining_) {
      BrokerError error;
      error.category_ = ErrorCategory::INVALID_ARGUMENT;
      error.reached_broker_ = false;
      error.broker_code_ = "partial_cancel_unsupported";
      error.message_ =
        "Toss cancels an order in full; use cancel_all() or modify the order to a smaller "
        "quantity instead of cancelling part of it";
      return Result<tossinvest::TossAmendment>(std::move(error));
    }
    tossinvest::TossAmendment amendment;
    amendment.order_id_ = ref.primary_;
    return Result<tossinvest::TossAmendment>(std::move(amendment));
  }

  static Result<tossinvest::TossOrderQuery> to_history_query(
    std::int64_t account_sequence,
    const OrderHistoryQuery& query
  ) {
    tossinvest::TossOrderQuery converted;
    converted.account_sequence_ = account_sequence;
    converted.scope_ = tossinvest::TossOrderScope::CLOSED;
    converted.symbol_ = query.symbol_;
    converted.from_ = query.from_;
    converted.to_ = query.to_;
    converted.cursor_ = query.cursor_;
    converted.limit_ = query.limit_;
    return Result<tossinvest::TossOrderQuery>(std::move(converted));
  }

  static tossinvest::TossOrderQuery open_query(std::int64_t account_sequence) {
    tossinvest::TossOrderQuery query;
    query.account_sequence_ = account_sequence;
    query.scope_ = tossinvest::TossOrderScope::OPEN;
    return query;
  }

  static std::int64_t selector_of(const tossinvest::TossAccount& account) {
    return account.sequence_;
  }

  static std::string display_of(const tossinvest::TossAccount& account) {
    return account.account_number_;
  }

  static std::string type_of(const tossinvest::TossAccount& account) {
    return account.account_type_;
  }
};

struct Capabilities {
  static constexpr bool has_account_discovery = true;

  static constexpr bool has_client_order_id = true;

  static constexpr bool has_trigger_price = false;

  static constexpr bool data_only = false;

  static constexpr bool has_working_orders = true;

  static constexpr bool has_amendable_quantity = false;

  static constexpr bool working_orders_state_terminal = false;

  static constexpr bool has_order_by_id = true;

  static constexpr bool has_partial_cancel = false;

  static constexpr bool history_requires_range = false;

  static constexpr bool has_history_cursor = true;

  static constexpr bool has_history_limit = true;

  static constexpr bool has_history_symbol_filter = true;
};
 
} // namespace traits_detail
} // namespace tossinvest

template <>
struct BrokerTraits<tossinvest::TossClient>
: tossinvest::traits_detail::Normalizers, tossinvest::traits_detail::Capabilities {
  static constexpr Venue effective_route(Venue) noexcept { return Venue::UNSPECIFIED; }

  using Client = tossinvest::TossClient;

  using Config = tossinvest::TossConfig;

  using Account = std::int64_t;

  using BrokerTag = tossinvest::Broker;

  using PlaceAck = OrderAck;

  using Amendment = tossinvest::TossAmendment;

  using HistoryQuery = tossinvest::TossOrderQuery;

  using WorkingOrdersResult = OrderPage;

  using AccountListItem = tossinvest::TossAccount;

  static constexpr std::string_view name = tossinvest::Broker::name;

  static constexpr bool blocking = false;

  static const network::RateLimitStats* rate_limit_stats(const Client& client) {
    return client.rate_limit_stats();
  }

  template <typename Token>
  static auto instrument(Client& client, InstrumentId subject, Token&& token) {
    return client.async_instrument(std::move(subject), std::forward<Token>(token));
  }

  template <typename Token>
  static auto calendar(Client& client, Country country, std::optional<Date> from, Token&& token) {
    return client.async_calendar(country, from, std::forward<Token>(token));
  }

  template <typename Token>
  static auto price_limits(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_price_limits(std::move(instrument), std::forward<Token>(token));
  }

  template <typename Token>
  static auto trades(Client& client, InstrumentId instrument, int count, Token&& token) {
    return client.async_trades(std::move(instrument), count, std::forward<Token>(token));
  }

  template <typename Token>
  static auto prices(Client& client, std::vector<InstrumentId> instruments, Token&& token) {
    return client.async_prices(std::move(instruments), std::forward<Token>(token));
  }

  template <typename Token>
  static auto depth(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_depth(std::move(instrument), std::forward<Token>(token));
  }

  template <typename Token>
  static auto bars(Client& client, BarQuery query, Token&& token) {
    return client.async_bars(std::move(query), std::forward<Token>(token));
  }

  template <typename Token>
  static auto quote(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_quote(std::move(instrument), std::forward<Token>(token));
  }

  template <typename Token>
  static auto accounts(Client& client, Token&& token) {
    return client.async_accounts(std::forward<Token>(token));
  }

  template <typename Token>
  static auto buying_power(Client& client, const Account& account, Currency currency, Token&& token) {
    return client.async_buying_power(currency, account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto sellable_quantity(
    Client& client,
    const Account& account,
    InstrumentId instrument,
    Token&& token
  ) {
    return client.async_sellable_quantity(std::move(instrument), account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto commissions(Client& client, const Account& account, Token&& token) {
    return client.async_commissions(account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto holdings(Client& client, const Account& account, Token&& token) {
    return client.async_holdings(account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto place_order(Client& client, const Account& account, OrderRequest order, Token&& token) {
    return client.async_place_order(account, std::move(order), std::forward<Token>(token));
  }

  template <typename Token>
  static auto replace_order(
    Client& client,
    const Account& account,
    Amendment amendment,
    Token&& token
  ) {
    return client.async_replace_order(account, std::move(amendment), std::forward<Token>(token));
  }

  template <typename Token>
  static auto cancel_order(
    Client& client,
    const Account& account,
    Amendment amendment,
    Token&& token
  ) {
    return client.async_cancel_order(
      account, std::move(amendment.order_id_), std::forward<Token>(token)
    );
  }

  template <typename Token>
  static auto working_orders(Client& client, const Account& account, Token&& token) {
    return client.async_orders(open_query(account), std::forward<Token>(token));
  }

  template <typename Token>
  static auto order_history(
    Client& client,
    const Account& account,
    HistoryQuery query,
    Token&& token
  ) {
    static_cast<void>(account);
    return client.async_orders(std::move(query), std::forward<Token>(token));
  }

  template <typename Token>
  static auto order_by_id(
    Client& client,
    const Account& account,
    std::string order_id,
    Token&& token
  ) {
    return client.async_order(account, std::move(order_id), std::forward<Token>(token));
  }
};

template <>
struct BrokerTraits<tossinvest::TossBlockingClient>
: tossinvest::traits_detail::Normalizers, tossinvest::traits_detail::Capabilities {
  static constexpr Venue effective_route(Venue) noexcept { return Venue::UNSPECIFIED; }

  using Client = tossinvest::TossBlockingClient;

  using Config = tossinvest::TossConfig;

  using Account = std::int64_t;

  using BrokerTag = tossinvest::Broker;

  using PlaceAck = OrderAck;

  using Amendment = tossinvest::TossAmendment;

  using HistoryQuery = tossinvest::TossOrderQuery;

  using WorkingOrdersResult = OrderPage;

  using AccountListItem = tossinvest::TossAccount;

  static constexpr std::string_view name = tossinvest::Broker::name;

  static constexpr bool blocking = true;

  static const network::RateLimitStats* rate_limit_stats(const Client& client) {
    return client.rate_limit_stats();
  }

  static Result<Instrument> instrument(Client& client, InstrumentId subject) {
    return client.instrument(std::move(subject));
  }

  static Result<TradingCalendar> calendar(Client& client, Country country, std::optional<Date> from) {
    return client.calendar(country, from);
  }

  static Result<PriceLimits> price_limits(Client& client, InstrumentId instrument) {
    return client.price_limits(std::move(instrument));
  }

  static Result<std::vector<TradePrint>> trades(
    Client& client,
    InstrumentId instrument,
    int count
  ) {
    return client.trades(std::move(instrument), count);
  }

  static Result<std::vector<QuoteSnapshot>> prices(
    Client& client,
    std::vector<InstrumentId> instruments
  ) {
    return client.prices(std::move(instruments));
  }

  static Result<DepthSnapshot> depth(Client& client, InstrumentId instrument) {
    return client.depth(std::move(instrument));
  }

  static Result<BarSeries> bars(Client& client, BarQuery query) {
    return client.bars(std::move(query));
  }

  static Result<QuoteSnapshot> quote(Client& client, InstrumentId instrument) {
    return client.quote(std::move(instrument));
  }

  static Result<std::vector<AccountListItem>> accounts(Client& client) {
    return client.accounts();
  }

  static Result<HoldingsSnapshot> holdings(Client& client, const Account& account) {
    return client.holdings(account);
  }

  static Result<BuyingPower> buying_power(
    Client& client,
    const Account& account,
    Currency currency
  ) {
    return client.buying_power(currency, account);
  }

  static Result<Decimal64> sellable_quantity(
    Client& client,
    const Account& account,
    InstrumentId instrument
  ) {
    return client.sellable_quantity(std::move(instrument), account);
  }

  static Result<CommissionSchedule> commissions(Client& client, const Account& account) {
    return client.commissions(account);
  }

  static Result<PlaceAck> place_order(Client& client, const Account& account, OrderRequest order) {
    return client.place_order(account, std::move(order));
  }

  static Result<PlaceAck> replace_order(
    Client& client,
    const Account& account,
    Amendment amendment
  ) {
    return client.replace_order(account, std::move(amendment));
  }

  static Result<PlaceAck> cancel_order(
    Client& client,
    const Account& account,
    Amendment amendment
  ) {
    return client.cancel_order(account, std::move(amendment.order_id_));
  }

  static Result<WorkingOrdersResult> working_orders(Client& client, const Account& account) {
    return client.orders(open_query(account));
  }

  static Result<OrderPage> order_history(
    Client& client,
    const Account& account,
    HistoryQuery query
  ) {
    static_cast<void>(account);
    return client.orders(std::move(query));
  }

  static Result<OrderSnapshot> order_by_id(
    Client& client,
    const Account& account,
    std::string order_id
  ) {
    return client.order(account, std::move(order_id));
  }
};
 
} // namespace algotradelib