broker_session.hpp

#pragma once
 
#include "./broker_caps.hpp"
#include "./broker_traits.hpp"
#include "./calendar.hpp"
#include "./instrument.hpp"
 
#include "../network/rate_limit.hpp"
 
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/async_result.hpp>
#include <boost/asio/bind_executor.hpp>
#include <boost/asio/post.hpp>
#include <boost/asio/system_executor.hpp>
 
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace algotradelib {
 
namespace net = boost::asio;
 
namespace port_detail {
 
// Converts a broker's account listing into `AccountInfo` rows (shared by both sessions).
template <typename Client, typename Items>
Result<std::vector<AccountInfo<Client>>> to_account_info(Result<Items> raw) {
  using Traits = BrokerTraits<Client>;
  using Accounts = std::vector<AccountInfo<Client>>;
  if (!raw) {
    return Result<Accounts>(std::move(raw.error()));
  }
  Accounts listed;
  listed.reserve(raw.value().size());
  for (const auto& item : raw.value()) {
    AccountInfo<Client> info;
    info.display_number_ = Traits::display_of(item);
    info.type_ = Traits::type_of(item);
    info.selector_ = Traits::selector_of(item);
    listed.push_back(std::move(info));
  }
  return Result<Accounts>(std::move(listed));
}

template <typename Client>
std::optional<BrokerError> trigger_refusal(const std::optional<Decimal64>& trigger) {
  if constexpr (BrokerCaps<Client>::has_trigger_price) {
    return std::nullopt;
  } else {
    if (!trigger) {
      return std::nullopt;
    }
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    error.broker_code_ = "unsupported_trigger_price";
    error.message_ =
      "this broker does not declare that it transmits a trigger price, so an order carrying one "
      "would be sent without it; place the order without a trigger or through a broker whose "
      "BrokerCaps::has_trigger_price is true";
    return error;
  }
}

template <typename Client>
std::optional<BrokerError> prepare_place(const OrderRequest& order) {
  if (auto refused = trigger_refusal<Client>(order.trigger_price_)) {
    return refused;
  }
  return BrokerTraits<Client>::validate_place(order);
}

template <typename Client>
Result<typename BrokerTraits<Client>::Amendment> prepare_replace(
  const OrderRef<typename BrokerTraits<Client>::BrokerTag>& ref, const AmendInstruction& instruction
) {
  using Amendment = typename BrokerTraits<Client>::Amendment;
  if (auto refused = trigger_refusal<Client>(amended_trigger_price(instruction))) {
    return Result<Amendment>(std::move(*refused));
  }
  return BrokerTraits<Client>::to_replacement(ref, instruction);
}
 
} // namespace port_detail

template <typename Client>
class BrokerSession {
public:
  using Traits = BrokerTraits<Client>;

  using Caps = BrokerCaps<Client>;

  using Account = typename Traits::Account;

  using Config = typename Traits::Config;

  using BrokerTag = typename Traits::BrokerTag;

  using Ref = OrderRef<BrokerTag>;

  using Placed = PlacedOrder<BrokerTag>;

  using Working = WorkingOrder<BrokerTag>;

  using WorkingSet = WorkingOrders<BrokerTag>;
 
  static_assert(
    !Traits::blocking,
    "BrokerSession requires an asynchronous client; use BlockingSession for a blocking facade"
  );

  BrokerSession(std::shared_ptr<Client> client, Account account)
  : client_(std::move(client)), account_(std::move(account)) {
    if (!client_) {
      throw std::invalid_argument("broker session requires a client");
    }
  }

  static constexpr std::string_view broker_name() noexcept { return Traits::name; }

  const Account& account() const noexcept { return account_; }

  Client& client() noexcept { return *client_; }

  const Client& client() const noexcept { return *client_; }

  const std::shared_ptr<Client>& shared_client() const noexcept { return client_; }

  const network::RateLimitStats* rate_limit_stats() const {
    return Traits::rate_limit_stats(*client_);
  }

  void close() { client_->close(); }

  template <typename CompletionToken>
  auto async_quote(InstrumentId instrument, CompletionToken&& token) {
    return translate<QuoteSnapshot>(
      std::forward<CompletionToken>(token),
      [client = client_, instrument = std::move(instrument)](auto&& sink) mutable {
        Traits::quote(*client, std::move(instrument), std::forward<decltype(sink)>(sink));
      },
      [](Result<QuoteSnapshot> raw) { return raw; }
    );
  }

  template <typename CompletionToken>
  auto async_holdings(CompletionToken&& token) {
    return translate<HoldingsSnapshot>(
      std::forward<CompletionToken>(token),
      [client = client_, account = account_](auto&& sink) mutable {
        Traits::holdings(*client, account, std::forward<decltype(sink)>(sink));
      },
      [](Result<HoldingsSnapshot> raw) { return raw; }
    );
  }

  template <typename CompletionToken>
  auto async_buying_power(Currency currency, CompletionToken&& token) {
    if constexpr (Caps::has_buying_power) {
      return translate<BuyingPower>(
        std::forward<CompletionToken>(token),
        [client = client_, account = account_, currency](auto&& sink) mutable {
          Traits::buying_power(*client, account, currency, std::forward<decltype(sink)>(sink));
        },
        [](Result<BuyingPower> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not answer what the account may spend; gate the call with "
        "BrokerCaps<Client>::has_buying_power"
      );
    }
  }

  template <typename CompletionToken>
  auto async_sellable_quantity(InstrumentId instrument, CompletionToken&& token) {
    if constexpr (Caps::sellable_source == SellableSource::INQUIRY) {
      return translate<Decimal64>(
        std::forward<CompletionToken>(token),
        [client = client_, account = account_, instrument = std::move(instrument)](
          auto&& sink
        ) mutable {
          Traits::sellable_quantity(
            *client, account, std::move(instrument), std::forward<decltype(sink)>(sink)
          );
        },
        [](Result<Decimal64> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker has no separate sellable-quantity inquiry; read "
        "HoldingPosition::sellable_quantity_ from the holdings snapshot, and gate on "
        "BrokerCaps<Client>::sellable_source"
      );
    }
  }

  template <typename CompletionToken>
  auto async_commissions(CompletionToken&& token) {
    if constexpr (Caps::has_commission_schedule) {
      return translate<CommissionSchedule>(
        std::forward<CompletionToken>(token),
        [client = client_, account = account_](auto&& sink) mutable {
          Traits::commissions(*client, account, std::forward<decltype(sink)>(sink));
        },
        [](Result<CommissionSchedule> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker publishes no commission schedule; gate the call with "
        "BrokerCaps<Client>::has_commission_schedule"
      );
    }
  }

  template <typename CompletionToken>
  auto async_place(OrderRequest order, CompletionToken&& token) {
    if (auto refused = port_detail::prepare_place<Client>(order)) {
      return complete_error<Placed>(
        std::forward<CompletionToken>(token), std::move(*refused)
      );
    }
    return translate<Placed>(
      std::forward<CompletionToken>(token),
      [client = client_, account = account_, order = std::move(order)](auto&& sink) mutable {
        Traits::place_order(
          *client, account, std::move(order), std::forward<decltype(sink)>(sink)
        );
      },
      [](Result<typename Traits::PlaceAck> raw) { return Traits::normalize_place(std::move(raw)); }
    );
  }

  template <typename CompletionToken>
  auto async_replace(Ref ref, AmendInstruction instruction, CompletionToken&& token) {
    auto amendment = port_detail::prepare_replace<Client>(ref, instruction);
    if (!amendment) {
      return complete_error<Placed>(
        std::forward<CompletionToken>(token), std::move(amendment.error())
      );
    }
    return translate<Placed>(
      std::forward<CompletionToken>(token),
      [
        client = client_,
        account = account_,
        value = std::move(amendment.value())
      ](auto&& sink) mutable {
        Traits::replace_order(
          *client, account, std::move(value), std::forward<decltype(sink)>(sink)
        );
      },
      [](Result<typename Traits::PlaceAck> raw) { return Traits::normalize_place(std::move(raw)); }
    );
  }

  template <typename CompletionToken>
  auto async_cancel(Ref ref, AmendInstruction instruction, CompletionToken&& token) {
    auto amendment = Traits::to_cancellation(ref, instruction);
    if (!amendment) {
      return complete_error<Placed>(
        std::forward<CompletionToken>(token), std::move(amendment.error())
      );
    }
    return translate<Placed>(
      std::forward<CompletionToken>(token),
      [
        client = client_,
        account = account_,
        value = std::move(amendment.value())
      ](auto&& sink) mutable {
        Traits::cancel_order(
          *client, account, std::move(value), std::forward<decltype(sink)>(sink)
        );
      },
      [](Result<typename Traits::PlaceAck> raw) { return Traits::normalize_place(std::move(raw)); }
    );
  }

  template <typename CompletionToken>
  auto async_working_orders(CompletionToken&& token) {
    if constexpr (Caps::has_working_orders) {
      return translate<WorkingSet>(
        std::forward<CompletionToken>(token),
        [client = client_, account = account_](auto&& sink) mutable {
          Traits::working_orders(*client, account, std::forward<decltype(sink)>(sink));
        },
        [](Result<typename Traits::WorkingOrdersResult> raw) {
          return Traits::normalize_working_orders(std::move(raw));
        }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish its amendable orders; gate the call with "
        "BrokerCaps<Client>::has_working_orders"
      );
    }
  }

  template <typename CompletionToken>
  auto async_order_history(OrderHistoryQuery query, CompletionToken&& token) {
    auto converted = Traits::to_history_query(account_, query);
    if (!converted) {
      return complete_error<OrderPage>(
        std::forward<CompletionToken>(token), std::move(converted.error())
      );
    }
    return translate<OrderPage>(
      std::forward<CompletionToken>(token),
      [
        client = client_,
        account = account_,
        value = std::move(converted.value())
      ](auto&& sink) mutable {
        Traits::order_history(
          *client, account, std::move(value), std::forward<decltype(sink)>(sink)
        );
      },
      [](Result<OrderPage> raw) { return raw; }
    );
  }

  template <typename CompletionToken>
  auto async_bars(BarQuery query, CompletionToken&& token) {
    if (auto invalid = Traits::validate_bars(query)) {
      return complete_error<BarSeries>(
        std::forward<CompletionToken>(token), std::move(*invalid)
      );
    }
    return translate<BarSeries>(
      std::forward<CompletionToken>(token),
      [client = client_, query = std::move(query)](auto&& sink) mutable {
        Traits::bars(*client, std::move(query), std::forward<decltype(sink)>(sink));
      },
      [](Result<BarSeries> raw) { return raw; }
    );
  }

  template <typename CompletionToken>
  auto async_instrument(InstrumentId instrument, CompletionToken&& token) {
    if constexpr (Caps::has_reference_data) {
      return translate<Instrument>(
        std::forward<CompletionToken>(token),
        [client = client_, instrument = std::move(instrument)](auto&& sink) mutable {
          Traits::instrument(*client, std::move(instrument), std::forward<decltype(sink)>(sink));
        },
        [](Result<Instrument> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish instrument reference data; gate the call with "
        "BrokerCaps<Client>::has_reference_data"
      );
    }
  }

  template <typename CompletionToken>
  auto async_calendar(Country country, std::optional<Date> from, CompletionToken&& token) {
    if constexpr (Caps::has_calendar) {
      if (auto invalid = Traits::validate_calendar(country, from)) {
        return complete_error<TradingCalendar>(
          std::forward<CompletionToken>(token), std::move(*invalid)
        );
      }
      return translate<TradingCalendar>(
        std::forward<CompletionToken>(token),
        [client = client_, country, from](auto&& sink) mutable {
          Traits::calendar(*client, country, from, std::forward<decltype(sink)>(sink));
        },
        [](Result<TradingCalendar> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish a trading calendar; gate the call with "
        "BrokerCaps<Client>::has_calendar"
      );
    }
  }

  template <typename CompletionToken>
  auto async_price_limits(InstrumentId instrument, CompletionToken&& token) {
    if constexpr (Caps::has_price_limits) {
      return translate<PriceLimits>(
        std::forward<CompletionToken>(token),
        [client = client_, instrument = std::move(instrument)](auto&& sink) mutable {
          Traits::price_limits(
            *client, std::move(instrument), std::forward<decltype(sink)>(sink)
          );
        },
        [](Result<PriceLimits> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish price limits; gate the call with "
        "BrokerCaps<Client>::has_price_limits"
      );
    }
  }

  template <typename CompletionToken>
  auto async_trades(InstrumentId instrument, int count, CompletionToken&& token) {
    if constexpr (Caps::has_trade_prints) {
      return translate<std::vector<TradePrint>>(
        std::forward<CompletionToken>(token),
        [client = client_, instrument = std::move(instrument), count](auto&& sink) mutable {
          Traits::trades(
            *client, std::move(instrument), count, std::forward<decltype(sink)>(sink)
          );
        },
        [](Result<std::vector<TradePrint>> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish recent executions; gate the call with "
        "BrokerCaps<Client>::has_trade_prints"
      );
    }
  }

  template <typename CompletionToken>
  auto async_prices(std::vector<InstrumentId> instruments, CompletionToken&& token) {
    if constexpr (Caps::has_batch_prices) {
      return translate<std::vector<QuoteSnapshot>>(
        std::forward<CompletionToken>(token),
        [client = client_, instruments = std::move(instruments)](auto&& sink) mutable {
          Traits::prices(*client, std::move(instruments), std::forward<decltype(sink)>(sink));
        },
        [](Result<std::vector<QuoteSnapshot>> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker quotes one instrument per request; gate the call with "
        "BrokerCaps<Client>::has_batch_prices and call async_quote per instrument"
      );
    }
  }

  template <typename CompletionToken>
  auto async_depth(InstrumentId instrument, CompletionToken&& token) {
    if constexpr (Caps::has_depth) {
      return translate<DepthSnapshot>(
        std::forward<CompletionToken>(token),
        [client = client_, instrument = std::move(instrument)](auto&& sink) mutable {
          Traits::depth(*client, std::move(instrument), std::forward<decltype(sink)>(sink));
        },
        [](Result<DepthSnapshot> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish an order book; gate the call with "
        "BrokerCaps<Client>::has_depth"
      );
    }
  }

  template <typename CompletionToken>
  auto async_order(Ref ref, CompletionToken&& token) {
    if constexpr (Caps::has_order_by_id) {
      return translate<OrderSnapshot>(
        std::forward<CompletionToken>(token),
        [client = client_, account = account_, id = ref.primary_](auto&& sink) mutable {
          Traits::order_by_id(*client, account, std::move(id), std::forward<decltype(sink)>(sink));
        },
        [](Result<OrderSnapshot> raw) { return raw; }
      );
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not retrieve one order by identifier; gate the call with "
        "BrokerCaps<Client>::has_order_by_id and read the order from "
        "async_working_orders or async_order_history instead"
      );
    }
  }
 
private:
  // Initiates one client call; normalization and the handler run once, on the handler's executor.
  template <typename Out, typename Token, typename Call, typename Normalize>
  static auto translate(Token&& token, Call call, Normalize normalize) {
    return net::async_initiate<Token, void(Result<Out>)>(
      [call = std::move(call), normalize = std::move(normalize)](auto&& handler) mutable {
        auto executor = net::get_associated_executor(handler);
        call(
          net::bind_executor(
            executor,
            [
              handler = std::forward<decltype(handler)>(handler),
              normalize = std::move(normalize)
            ](auto raw) mutable {
              std::move(handler)(normalize(std::move(raw)));
            }
          )
        );
      },
      token
    );
  }
 
  // Completes with a pre-flight error, posted (never inline) to the handler's executor, or the
  // system executor if it has none.
  template <typename Out, typename Token>
  static auto complete_error(Token&& token, BrokerError error) {
    return net::async_initiate<Token, void(Result<Out>)>(
      [error = std::move(error)](auto&& handler) mutable {
        auto executor = net::get_associated_executor(handler, net::system_executor());
        net::post(
          executor,
          [
            handler = std::forward<decltype(handler)>(handler),
            error = std::move(error)
          ]() mutable {
            std::move(handler)(Result<Out>(std::move(error)));
          }
        );
      },
      token
    );
  }
 
  std::shared_ptr<Client> client_;
  Account account_;
};

template <typename Client>
class BlockingSession {
public:
  using Traits = BrokerTraits<Client>;

  using Caps = BrokerCaps<Client>;

  using Account = typename Traits::Account;

  using Config = typename Traits::Config;

  using BrokerTag = typename Traits::BrokerTag;

  using Ref = OrderRef<BrokerTag>;

  using Placed = PlacedOrder<BrokerTag>;

  using Working = WorkingOrder<BrokerTag>;

  using WorkingSet = WorkingOrders<BrokerTag>;
 
  static_assert(
    Traits::blocking,
    "BlockingSession requires a blocking client facade; use BrokerSession for an "
    "asynchronous client"
  );

  BlockingSession(std::shared_ptr<Client> client, Account account)
  : client_(std::move(client)), account_(std::move(account)) {
    if (!client_) {
      throw std::invalid_argument("broker session requires a client");
    }
  }

  static constexpr std::string_view broker_name() noexcept { return Traits::name; }

  const Account& account() const noexcept { return account_; }

  Client& client() noexcept { return *client_; }

  const Client& client() const noexcept { return *client_; }

  const network::RateLimitStats* rate_limit_stats() const {
    return Traits::rate_limit_stats(*client_);
  }

  Result<QuoteSnapshot> quote(InstrumentId instrument) {
    return Traits::quote(*client_, std::move(instrument));
  }

  Result<HoldingsSnapshot> holdings() { return Traits::holdings(*client_, account_); }

  Result<BuyingPower> buying_power(Currency currency) {
    if constexpr (Caps::has_buying_power) {
      return Traits::buying_power(*client_, account_, currency);
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not answer what the account may spend; gate the call with "
        "BrokerCaps<Client>::has_buying_power"
      );
    }
  }

  Result<Decimal64> sellable_quantity(InstrumentId instrument) {
    if constexpr (Caps::sellable_source == SellableSource::INQUIRY) {
      return Traits::sellable_quantity(*client_, account_, std::move(instrument));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker has no separate sellable-quantity inquiry; read "
        "HoldingPosition::sellable_quantity_ from the holdings snapshot, and gate on "
        "BrokerCaps<Client>::sellable_source"
      );
    }
  }

  Result<CommissionSchedule> commissions() {
    if constexpr (Caps::has_commission_schedule) {
      return Traits::commissions(*client_, account_);
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker publishes no commission schedule; gate the call with "
        "BrokerCaps<Client>::has_commission_schedule"
      );
    }
  }

  Result<Instrument> instrument(InstrumentId subject) {
    if constexpr (Caps::has_reference_data) {
      return Traits::instrument(*client_, std::move(subject));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish instrument reference data; gate the call with "
        "BrokerCaps<Client>::has_reference_data"
      );
    }
  }

  Result<TradingCalendar> calendar(Country country, std::optional<Date> from = std::nullopt) {
    if constexpr (Caps::has_calendar) {
      if (auto invalid = Traits::validate_calendar(country, from)) {
        return Result<TradingCalendar>(std::move(*invalid));
      }
      return Traits::calendar(*client_, country, from);
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish a trading calendar; gate the call with "
        "BrokerCaps<Client>::has_calendar"
      );
    }
  }

  Result<PriceLimits> price_limits(InstrumentId instrument) {
    if constexpr (Caps::has_price_limits) {
      return Traits::price_limits(*client_, std::move(instrument));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish price limits; gate the call with "
        "BrokerCaps<Client>::has_price_limits"
      );
    }
  }

  Result<std::vector<TradePrint>> trades(InstrumentId instrument, int count) {
    if constexpr (Caps::has_trade_prints) {
      return Traits::trades(*client_, std::move(instrument), count);
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish recent executions; gate the call with "
        "BrokerCaps<Client>::has_trade_prints"
      );
    }
  }

  Result<std::vector<QuoteSnapshot>> prices(std::vector<InstrumentId> instruments) {
    if constexpr (Caps::has_batch_prices) {
      return Traits::prices(*client_, std::move(instruments));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker quotes one instrument per request; gate the call with "
        "BrokerCaps<Client>::has_batch_prices and call quote per instrument"
      );
    }
  }

  Result<DepthSnapshot> depth(InstrumentId instrument) {
    if constexpr (Caps::has_depth) {
      return Traits::depth(*client_, std::move(instrument));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish an order book; gate the call with "
        "BrokerCaps<Client>::has_depth"
      );
    }
  }

  Result<BarSeries> bars(BarQuery query) {
    if (auto invalid = Traits::validate_bars(query)) {
      return Result<BarSeries>(std::move(*invalid));
    }
    return Traits::bars(*client_, std::move(query));
  }

  Result<Placed> place(OrderRequest order) {
    if (auto refused = port_detail::prepare_place<Client>(order)) {
      return Result<Placed>(std::move(*refused));
    }
    return Traits::normalize_place(Traits::place_order(*client_, account_, std::move(order)));
  }

  Result<Placed> replace(const Ref& ref, const AmendInstruction& instruction) {
    auto amendment = port_detail::prepare_replace<Client>(ref, instruction);
    if (!amendment) {
      return Result<Placed>(std::move(amendment.error()));
    }
    return Traits::normalize_place(
      Traits::replace_order(*client_, account_, std::move(amendment.value()))
    );
  }

  Result<Placed> cancel(const Ref& ref, const AmendInstruction& instruction) {
    auto amendment = Traits::to_cancellation(ref, instruction);
    if (!amendment) {
      return Result<Placed>(std::move(amendment.error()));
    }
    return Traits::normalize_place(
      Traits::cancel_order(*client_, account_, std::move(amendment.value()))
    );
  }

  Result<WorkingSet> working_orders() {
    if constexpr (Caps::has_working_orders) {
      return Traits::normalize_working_orders(Traits::working_orders(*client_, account_));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish its amendable orders; gate the call with "
        "BrokerCaps<Client>::has_working_orders"
      );
    }
  }

  Result<OrderPage> order_history(const OrderHistoryQuery& query) {
    auto converted = Traits::to_history_query(account_, query);
    if (!converted) {
      return Result<OrderPage>(std::move(converted.error()));
    }
    return Traits::order_history(*client_, account_, std::move(converted.value()));
  }

  Result<OrderSnapshot> order(const Ref& ref) {
    if constexpr (Caps::has_order_by_id) {
      return Traits::order_by_id(*client_, account_, ref.primary_);
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not retrieve one order by identifier; gate the call with "
        "BrokerCaps<Client>::has_order_by_id and read the order from working_orders or "
        "order_history instead"
      );
    }
  }

  Result<std::vector<AccountInfo<Client>>> accounts() {
    if constexpr (Caps::has_account_discovery) {
      return port_detail::to_account_info<Client>(Traits::accounts(*client_));
    } else {
      static_assert(
        port_detail::dependent_false<Client>,
        "this broker does not publish selectable accounts; its account selector comes from "
        "configuration, so gate the call with BrokerCaps<Client>::has_account_discovery"
      );
    }
  }
 
private:
  std::shared_ptr<Client> client_;
  Account account_;
};

template <typename Client, typename CompletionToken>
auto async_accounts(Client& client, CompletionToken&& token) {
  if constexpr (BrokerCaps<Client>::has_account_discovery) {
    using Traits = BrokerTraits<Client>;
    using Accounts = std::vector<AccountInfo<Client>>;
    return net::async_initiate<CompletionToken, void(Result<Accounts>)>(
      [&client](auto&& handler) mutable {
        auto executor = net::get_associated_executor(handler);
        Traits::accounts(
          client,
          net::bind_executor(
            executor,
            [handler = std::forward<decltype(handler)>(handler)](auto raw) mutable {
              std::move(handler)(port_detail::to_account_info<Client>(std::move(raw)));
            }
          )
        );
      },
      token
    );
  } else {
    static_assert(
      port_detail::dependent_false<Client>,
      "this broker does not publish selectable accounts; its account selector comes from "
      "configuration, so gate the call with BrokerCaps<Client>::has_account_discovery"
    );
  }
}

template <typename Client>
Result<std::vector<AccountInfo<Client>>> list_accounts(Client& client) {
  if constexpr (BrokerCaps<Client>::has_account_discovery) {
    return port_detail::to_account_info<Client>(BrokerTraits<Client>::accounts(client));
  } else {
    static_assert(
      port_detail::dependent_false<Client>,
      "this broker does not publish selectable accounts; its account selector comes from "
      "configuration, so gate the call with BrokerCaps<Client>::has_account_discovery"
    );
  }
}
 
} // namespace algotradelib