From 1b232aa610ea25faf19e3653aa2aae21cad9cc89 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Fri, 6 Dec 2024 20:24:08 +0000 Subject: [PATCH] feat: Add Binance USDS Futures execution --- CMakeLists.txt | 1 + .../api/service_helpers/AdminServiceUtils.cpp | 8 +- .../api/service_helpers/AdminServiceUtils.h | 12 + src/lib/io/http/http_request.h | 9 + src/lib/orderman/OrderServiceServer.cpp | 32 +- src/lib/orderman/OrderServiceServer.h | 3 + src/lib/orderman/OrderServices.cpp | 2 +- .../actors/order_manager/OrderManager.cpp | 42 +- .../actors/order_manager/OrderManager.h | 5 +- .../order_manager/OrderServicesData.cpp | 17 +- .../actors/order_manager/OrderServicesData.h | 47 +- .../order_manager/order_gateway_definition.h | 15 + .../order_manager/session_services_data.h | 61 +++ .../orderman/gateways/IExecutionGateway.cpp | 7 + src/lib/orderman/gateways/IExecutionGateway.h | 9 +- .../gateways/execution_gateway_provider.cpp | 31 ++ .../gateways/execution_gateway_provider.h | 22 + .../gateways/i_execution_gateway_provider.cpp | 7 + .../gateways/i_execution_gateway_provider.h | 17 + src/lib/orderman/orders/EMNativeOrder.cpp | 5 +- src/lib/utils/checked_arithmetic.h | 33 +- src/lib/utils/crypto/hmac.cpp | 44 ++ src/lib/utils/crypto/hmac.h | 18 + src/lib/utils/file_utils.cpp | 17 + src/lib/utils/file_utils.h | 4 + src/lib/utils/string_utils.h | 86 ++++ src/lib_binance_execution/CMakeLists.txt | 17 + .../enums/event_reason_type.h | 44 ++ .../binance_execution/enums/execution_type.h | 32 ++ .../binance_execution/enums/order_status.h | 34 ++ .../binance_execution/enums/order_type.h | 27 ++ .../binance_execution/enums/position_side.h | 25 ++ .../enums/price_match_mode.h | 30 ++ .../enums/self_trade_prevention_mode.h | 22 + .../binance_execution/enums/side.h | 24 ++ .../binance_execution/enums/time_in_force.h | 30 ++ .../binance_execution/enums/working_type.h | 23 + .../execution_gateway_provider.cpp | 40 ++ .../execution_gateway_provider.h | 24 ++ .../binance_execution/price.h | 40 ++ .../binance_execution/quantity.h | 40 ++ .../usds_futures/execution_gateway.cpp | 405 ++++++++++++++++++ .../usds_futures/execution_gateway.h | 43 ++ .../usds_futures/execution_gateway_config.h | 37 ++ .../messages/all_orders_request.h | 109 +++++ .../messages/cancel_order_request.h | 66 +++ .../messages/cancel_order_response.h | 112 +++++ .../messages/create_order_request.h | 120 ++++++ .../messages/create_order_response.h | 113 +++++ .../messages/listen_key_request.h | 15 + .../messages/listen_key_response.h | 17 + .../messages/modify_order_request.h | 107 +++++ .../messages/modify_order_response.h | 114 +++++ .../messages/open_orders_request.h | 121 ++++++ .../usds_futures/messages/order_record.h | 104 +++++ .../usds_futures/messages/position_info.h | 92 ++++ .../messages/position_info_request.h | 62 +++ .../usds_futures/rest_api_client.cpp | 109 +++++ .../usds_futures/rest_api_client.h | 136 ++++++ .../usds_futures/rest_api_result.h | 36 ++ .../usds_futures/type_converters.cpp | 147 +++++++ .../usds_futures/type_converters.h | 263 ++++++++++++ .../user_data_streams/account_update.h | 133 ++++++ .../listen_key_requestor.cpp | 81 ++++ .../user_data_streams/listen_key_requestor.h | 30 ++ .../user_data_streams/order_update.cpp | 81 ++++ .../user_data_streams/order_update.h | 89 ++++ .../user_data_subscription.cpp | 163 +++++++ .../user_data_subscription.h | 30 ++ src/server/sparkd/CMakeLists.txt | 1 + src/server/sparkd/cmds/Run.cpp | 37 +- 71 files changed, 3913 insertions(+), 66 deletions(-) create mode 100644 src/lib/orderman/actors/order_manager/order_gateway_definition.h create mode 100644 src/lib/orderman/actors/order_manager/session_services_data.h create mode 100644 src/lib/orderman/gateways/IExecutionGateway.cpp create mode 100644 src/lib/orderman/gateways/execution_gateway_provider.cpp create mode 100644 src/lib/orderman/gateways/execution_gateway_provider.h create mode 100644 src/lib/orderman/gateways/i_execution_gateway_provider.cpp create mode 100644 src/lib/orderman/gateways/i_execution_gateway_provider.h create mode 100644 src/lib/utils/crypto/hmac.cpp create mode 100644 src/lib/utils/crypto/hmac.h create mode 100644 src/lib/utils/string_utils.h create mode 100644 src/lib_binance_execution/CMakeLists.txt create mode 100644 src/lib_binance_execution/binance_execution/enums/event_reason_type.h create mode 100644 src/lib_binance_execution/binance_execution/enums/execution_type.h create mode 100644 src/lib_binance_execution/binance_execution/enums/order_status.h create mode 100644 src/lib_binance_execution/binance_execution/enums/order_type.h create mode 100644 src/lib_binance_execution/binance_execution/enums/position_side.h create mode 100644 src/lib_binance_execution/binance_execution/enums/price_match_mode.h create mode 100644 src/lib_binance_execution/binance_execution/enums/self_trade_prevention_mode.h create mode 100644 src/lib_binance_execution/binance_execution/enums/side.h create mode 100644 src/lib_binance_execution/binance_execution/enums/time_in_force.h create mode 100644 src/lib_binance_execution/binance_execution/enums/working_type.h create mode 100644 src/lib_binance_execution/binance_execution/execution_gateway_provider.cpp create mode 100644 src/lib_binance_execution/binance_execution/execution_gateway_provider.h create mode 100644 src/lib_binance_execution/binance_execution/price.h create mode 100644 src/lib_binance_execution/binance_execution/quantity.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.cpp create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/execution_gateway_config.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/all_orders_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_response.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_response.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_response.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_response.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/open_orders_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/order_record.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/position_info.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/messages/position_info_request.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.cpp create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/rest_api_result.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/type_converters.cpp create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/type_converters.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/account_update.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.cpp create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.cpp create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.h create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.cpp create mode 100644 src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.h diff --git a/CMakeLists.txt b/CMakeLists.txt index e0813e5d9..0689b3220 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -91,6 +91,7 @@ else() add_compile_definitions(CCAPI_BINANCE_USDS_FUTURES_URL_REST_BASE="https://dapi.binance.com") add_compile_definitions(BINANCE_USDS_FUTURES_INSTRUMENTS_PATH="/dapi/v1/exchangeInfo") add_compile_definitions(BINANCE_USDS_FUTURES_PRICE_STATS_PATH="/dapi/v1/ticker/24hr") + add_compile_definitions(BINANCE_USDS_FUTURES_USER_DATA_PATH="/api/v3/userDataStream") # ** Binance Coin Futures ** add_compile_definitions(CCAPI_BINANCE_COIN_FUTURES_URL_REST_BASE="https://dapi.binance.com") diff --git a/src/lib/api/service_helpers/AdminServiceUtils.cpp b/src/lib/api/service_helpers/AdminServiceUtils.cpp index 447ac63dd..558a439d2 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.cpp +++ b/src/lib/api/service_helpers/AdminServiceUtils.cpp @@ -767,12 +767,18 @@ bts::api::orderman::RoutingRecord AdminServiceUtils::get_routing_record( out_result.set_is_success(true); return rv; } + case api::VENUE_BINANCE_USDS_FUTURES: { + rv.set_session("binance_usds_futures_1"); + rv.set_account(account_ptr->name()); + rv.set_account(user_ptr->name()); + out_result.set_is_success(true); + return rv; + } case api::VENUE_FTX: // TODO case api::VENUE_BINANCE: // TODO case api::VENUE_BINANCE_COIN_FUTURES: case api::VENUE_BINANCE_US: case api::Venue::VENUE_COINBASE: - case api::VENUE_BINANCE_USDS_FUTURES: case api::Venue::VENUE_UNSET: case api::Venue::VENUE_BTS: case api::Venue::VENUE_CBOECFE: diff --git a/src/lib/api/service_helpers/AdminServiceUtils.h b/src/lib/api/service_helpers/AdminServiceUtils.h index 1e3dac528..694b016d0 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.h +++ b/src/lib/api/service_helpers/AdminServiceUtils.h @@ -41,6 +41,18 @@ class AdminServiceUtils { } return nullptr; } + + bts::config::toggles::ExchangeSubAccountUnit const *find_entry( + const std::string &account, bool is_internal_account) { + for (const auto &esa : exch_sub_accounts.accounts()) { + const auto &a = is_internal_account ? esa.bts_account_name() + : esa.exchange_subaccount(); + if (a == account) { + return &esa; + } + } + return nullptr; + } }; //////////////////////////////////////////// // connection accessors //////////////////// diff --git a/src/lib/io/http/http_request.h b/src/lib/io/http/http_request.h index 200d6edd2..64e73865c 100644 --- a/src/lib/io/http/http_request.h +++ b/src/lib/io/http/http_request.h @@ -14,12 +14,21 @@ class HttpRequest { std::string body; io::http::HttpMethod method; std::unordered_map headers; + + void reset(); }; ////////////////////////////////////////////////// // Definition ////////////////////////////////////////////////// +inline void HttpRequest::reset() { + url.clear(); + body.clear(); + method = io::http::HttpMethod::NONE; + headers.clear(); +} + inline void to_json(nlohmann::json &j, const HttpRequest &req) { j["url"] = req.url; j["body"] = req.body; diff --git a/src/lib/orderman/OrderServiceServer.cpp b/src/lib/orderman/OrderServiceServer.cpp index 65f7b8571..5e86a8218 100644 --- a/src/lib/orderman/OrderServiceServer.cpp +++ b/src/lib/orderman/OrderServiceServer.cpp @@ -13,6 +13,7 @@ #include "lib/logging/logging.h" #include "lib/md/MDClient.h" #include "lib/md/MDConsumer.h" +#include "lib/md/UserSymbol.h" #include "lib/mercury/actors/Timer.h" #include "lib/mercury/executor/Executor.h" #include "lib/metrics/metrics.h" @@ -24,16 +25,23 @@ #include "lib/orderman/actors/SecuritySrc.h" #include "lib/orderman/actors/ServiceBridge.h" #include "lib/orderman/actors/order_manager/OrderManager.h" +#include "lib/orderman/actors/order_manager/OrderServicesData.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" #include "lib/orderman/events/ExchangePositionEvent.h" #include "lib/orderman/events/OrderOpResultEvent.h" +#include "lib/orderman/gateways/execution_gateway_provider.h" +#include "lib/orderman/gateways/i_execution_gateway_provider.h" #include "lib/orderman/order_factory/DynamicOrderRegistry.h" #include "lib/orderman/orderman_utils/ExchangeOpenOrders.h" +#include "lib/orderman/orders/Order.h" +#include "lib/os/spark_data_directory.h" #include "lib/plugin/SparkServices.h" #include "lib/plugin/plugin.h" #include "lib/utils/PBUtils.h" #include "lib/utils/bts_chrono.h" #include "lib/utils/thread_manager.h" #include "lib/utils/type_name.h" +#include "lib_binance_execution/binance_execution/execution_gateway_provider.h" #include #include @@ -43,6 +51,8 @@ namespace bts { namespace orderman { +using std::unique_ptr; +using std::vector; struct ActorThread { ActorThread( @@ -126,10 +136,13 @@ struct OrderServiceServer::PImpl { const Exchange_open_ordersStatefulPublisher &open_orders_publisher, md::MDClient &mdc, DynamicOrderRegistry const &d, + std::vector> + gateway_providers, metrics::MetricsContainer &stats, trace::PerfLog &log) - : context(ctx), service_bridge(), service_ready(false), known_orders(), - known_fills(), publish_orders(), publish_fills(), + : context(ctx), service_bridge(), + gateway_providers(std::move(gateway_providers)), service_ready(false), + known_orders(), known_fills(), publish_orders(), publish_fills(), exchange_pos_publisher(exchange_pos_publisher), open_orders_publisher(open_orders_publisher), admin_service(ctx.locate()), @@ -137,11 +150,15 @@ struct OrderServiceServer::PImpl { margin_service(ctx.locate()), md_consumer(mdc.current_consumer()), stats(stats), dyn_order_registry(d), log(log), in_flight_order_ops(), - current_req_op_id(0) {} + current_req_op_id(0) { + LOG(OrderMan, Info, "OrderServiceServer ctr. n_gateway_providers: {}", + this->gateway_providers.size()); + } bts::api::ServiceContext &context; ServiceBridge *service_bridge; + std::vector> gateway_providers; std::vector> actor_threads; std::atomic service_ready; @@ -169,6 +186,7 @@ OrderServiceServer::OrderServiceServer( bts::api::ServiceContext &ctx, md::MDClient &mdc, DynamicOrderRegistry const &d, + std::vector> gateway_providers, metrics::MetricsContainer &stats, trace::PerfLog &log, md::TradeSummarySignalDispatcher &tssd) @@ -179,6 +197,7 @@ OrderServiceServer::OrderServiceServer( make_exchange_open_orders_stateful_publisher(), mdc, d, + std::move(gateway_providers), stats, log)) { LOG(md, Info, "OrderServiceServer cons t_id: {} t_name: {}", @@ -209,7 +228,10 @@ OrderServiceServer::OrderServiceServer( bts_assert_msg( thread, "Could not find a configured thread for OrderManager. See " "the OrdermanCfg key"); - thread->executor.spawn(d, me->log, mdc.oracle()); + { + thread->executor.spawn( + d, me->log, mdc.oracle(), std::move(me->gateway_providers)); + } // Timer thread = find_thread_for_actor("Timer", me->actor_threads); @@ -404,7 +426,6 @@ void OrderServiceServer::create_order( void OrderServiceServer::cancel_order( const api::orderman::Cancel &cancel, const api::Response &r) { - if (!me->service_ready) { api::orderman::Response response; response.set_order_key(cancel.order_key()); @@ -435,7 +456,6 @@ void OrderServiceServer::update_order( void OrderServiceServer::detach_order( const api::orderman::Detach &detach, const api::Response &r) { - if (!me->service_ready) { api::orderman::Response response; response.set_order_key(detach.order_key()); diff --git a/src/lib/orderman/OrderServiceServer.h b/src/lib/orderman/OrderServiceServer.h index ed5ab64f6..1cf98dd1d 100644 --- a/src/lib/orderman/OrderServiceServer.h +++ b/src/lib/orderman/OrderServiceServer.h @@ -5,6 +5,7 @@ #include "lib/md/MDClient.h" #include "lib/mercury/actors/IPollableActor.h" #include "lib/orderman/events/ExchangeOpenOrdersEvent.h" +#include "lib/orderman/gateways/i_execution_gateway_provider.h" #include namespace bts { @@ -28,6 +29,8 @@ class OrderServiceServer : public api::orderman::OrderServiceBase { bts::api::ServiceContext &context, md::MDClient &, DynamicOrderRegistry const &, + std::vector> + gateway_providers, metrics::MetricsContainer &, trace::PerfLog &, md::TradeSummarySignalDispatcher &); diff --git a/src/lib/orderman/OrderServices.cpp b/src/lib/orderman/OrderServices.cpp index 8c34cac14..1b6f6815f 100644 --- a/src/lib/orderman/OrderServices.cpp +++ b/src/lib/orderman/OrderServices.cpp @@ -190,7 +190,7 @@ SessionServices &OrderServices::get_session_services( for (auto &s : _sessions) if (s.session_name() == for_session) return s; - bts_assert(false); + bts_assert_msgf(false, "No session named '{}'", for_session); } void OrderServices::unsubscribe_from_order_creation_reply( diff --git a/src/lib/orderman/actors/order_manager/OrderManager.cpp b/src/lib/orderman/actors/order_manager/OrderManager.cpp index 0dd315191..93edc4a24 100644 --- a/src/lib/orderman/actors/order_manager/OrderManager.cpp +++ b/src/lib/orderman/actors/order_manager/OrderManager.cpp @@ -1,10 +1,15 @@ #include "OrderManager.h" +#include "lib/config/protos/jetfix.pb.h" +#include "lib/core/FMT.h" #include "lib/jetfix/common/OutFIX.h" #include "lib/logging/logging.h" +#include "lib/md/SecurityOracle.h" #include "lib/mercury/events/TimerEvent.h" #include "lib/orderman/OrderServices.h" #include "lib/orderman/actors/order_manager/OrderServicesData.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/actors/order_manager/session_services_data.h" #include "lib/orderman/events/AccountPnLUpdateEvent.h" #include "lib/orderman/events/ExcessLiquidityUpdateEvent.h" #include "lib/orderman/events/ExchangeOpenOrdersEvent.h" @@ -17,10 +22,13 @@ #include "lib/orderman/events/StoredOrderEvent.h" #include "lib/orderman/events/TheoEvent.h" #include "lib/orderman/gateways/IExecutionGateway.h" +#include "lib/orderman/gateways/i_execution_gateway_provider.h" #include "lib/orderman/order_factory/OrderFactory.h" #include "lib/orderman/orderman_utils/ExchangePosition.h" #include "lib/orderman/orders/Order.h" #include "lib/orderman/securities/ISecurityDB.h" +#include "lib/os/spark_data_directory.h" +#include "lib/tracing/PerfLog.h" #include "lib/utils/bts_assert.h" #include "lib/utils/inplace_function.h" #include "lib/utils/thread_manager.h" @@ -42,13 +50,27 @@ enum class OrderManager::State { READY }; +static std::vector create_gateways( + std::vector> providers) { + std::vector gws; + for (auto &p : providers) { + auto defs = p->create(); + for (auto &def : defs) { + gws.push_back(std::move(def)); + } + } + return gws; +} + struct OrderManager::PImpl { PImpl( OrderManager &owner, DynamicOrderRegistry const &b, trace::PerfLog &l, - md::SecurityOracle o) - : state(State::WAIT_ADMIN), services_data(owner, b, l, o) {} + md::SecurityOracle o, + std::vector gateways) + : state(State::WAIT_ADMIN), + services_data(owner, b, l, o, std::move(gateways)) {} State state; std::unordered_map orders; @@ -61,8 +83,12 @@ struct OrderManager::PImpl { }; OrderManager::OrderManager( - DynamicOrderRegistry const &b, trace::PerfLog &l, md::SecurityOracle o) - : me(new PImpl(*this, b, l, o)) { + DynamicOrderRegistry const &b, + trace::PerfLog &l, + md::SecurityOracle o, + std::vector> gw_providers) + : me(std::make_unique( + *this, b, l, o, create_gateways(std::move(gw_providers)))) { LOG(OrderMan, Info, "OrderManager cons t_id: {} t_name: {}", os::get_thread_id(), os::get_thread_name()); auto id_gen = &me->services_data.id_gen; @@ -437,6 +463,14 @@ std::vector &OrderManager::free_buffers( void OrderManager::init_order_services() { auto &log = me->services_data.log; + const std::string session_names = fmt::to_string(fmt::join( + me->services_data.sessions | + ranges::views::transform( + [](const std::unique_ptr &s) { + return s->session; + }), + ", ")); + LOG(OrderMan, Info, "init_order_services. sessions: {}", session_names); for (auto &s : me->services_data.sessions) { auto gw_name = GatewayName(s->session); diff --git a/src/lib/orderman/actors/order_manager/OrderManager.h b/src/lib/orderman/actors/order_manager/OrderManager.h index 1df5e8801..3a88646b8 100644 --- a/src/lib/orderman/actors/order_manager/OrderManager.h +++ b/src/lib/orderman/actors/order_manager/OrderManager.h @@ -5,11 +5,13 @@ #include "lib/md/SecurityOracle.h" #include "lib/mercury/actors/Actor.h" #include "lib/mercury/actors/IPollableActor.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" #include "lib/orderman/events/ActivateOrderEvent.h" #include "lib/orderman/events/CancelOrderEvent.h" #include "lib/orderman/events/DetachOrderEvent.h" #include "lib/orderman/events/RFQEvent.h" #include "lib/orderman/events/UpdateOrderEvent.h" +#include "lib/orderman/gateways/i_execution_gateway_provider.h" #include "lib/utils/inplace_function.h" #include @@ -68,7 +70,8 @@ class OrderManager : public mercury::Actor, public mercury::IPollableActor { OrderManager( DynamicOrderRegistry const &dyn_order_builder, trace::PerfLog &, - md::SecurityOracle); + md::SecurityOracle, + std::vector> gw_providers); ~OrderManager(); void init() override; diff --git a/src/lib/orderman/actors/order_manager/OrderServicesData.cpp b/src/lib/orderman/actors/order_manager/OrderServicesData.cpp index 98fb1dd1d..c9438e71b 100644 --- a/src/lib/orderman/actors/order_manager/OrderServicesData.cpp +++ b/src/lib/orderman/actors/order_manager/OrderServicesData.cpp @@ -1,6 +1,11 @@ #include "OrderServicesData.h" #include "lib/config/config.h" #include "lib/config/protos/jetfix.pb.h" +#include "lib/md/SecurityOracle.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/gateways/ExecutionGatewayFactory.h" +#include "lib/os/spark_data_directory.h" +#include "lib/tracing/PerfLog.h" namespace bts { namespace orderman { @@ -9,7 +14,8 @@ OrderServicesData::OrderServicesData( OrderManager &owner, DynamicOrderRegistry const &b, trace::PerfLog &l, - md::SecurityOracle o) + md::SecurityOracle o, + std::vector gateways) : owner(owner), log(l), sec_db(o), order_router(), order_factory(sec_db, order_router, b), last_timer_ev( @@ -17,9 +23,12 @@ OrderServicesData::OrderServicesData( to(datetime::FIX_timestamp(datetime::now()))), id_gen("orderman_ids", 5000) { - auto &all_connections = config::get().connection(); - for (auto const &c : all_connections) - sessions.push_back(std::make_unique(c, l, o)); + for (auto &g : gateways) { + sessions.push_back(std::make_unique(std::move(g))); + } + // spark::SparkDataDirectory data_dir; + // auto binance_j = data_dir.load_config_json("binance_execution"); } + } // namespace orderman } // namespace bts diff --git a/src/lib/orderman/actors/order_manager/OrderServicesData.h b/src/lib/orderman/actors/order_manager/OrderServicesData.h index 9b0083f71..e6958415a 100644 --- a/src/lib/orderman/actors/order_manager/OrderServicesData.h +++ b/src/lib/orderman/actors/order_manager/OrderServicesData.h @@ -1,4 +1,5 @@ #pragma once + #include "lib/logging/logging.h" #include "lib/md/SecurityOracle.h" #include "lib/mercury/actors/ContentSubscription.h" @@ -7,6 +8,8 @@ #include "lib/orderman/Governor.h" #include "lib/orderman/OrderRouter.h" #include "lib/orderman/actors/order_manager/PositionIndex.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/actors/order_manager/session_services_data.h" #include "lib/orderman/events/ActivateOrderEvent.h" #include "lib/orderman/events/BookUpdateEvent.h" #include "lib/orderman/events/CancelOrderEvent.h" @@ -53,54 +56,14 @@ struct ParentKey { } }; -struct SessionServicesData { - SessionServicesData( - config::JetFIX::Connection const &cfg, - trace::PerfLog &log, - md::SecurityOracle o) - : session(cfg.name()), gw_connected(false), cfg(cfg), - governor(cfg.max_order_msgs_per_window(), cfg.window_duration_msecs()), - gw(ExecutionGatewayFactory::create_gateway(cfg, log, o)) { - buffered_order_msgs.reserve(1000); - LOG(OrderMan, Info, "SessionServicesData::SessionServicesData cfg: {}", - utils::pb::to_string(cfg)); - } - - std::string session; - std::vector free_buffers; - bool gw_connected; - config::JetFIX::Connection cfg; - std::unique_ptr> - exe_report_subs; - std::unique_ptr> - cancel_reject_subs; - std::unique_ptr< - mercury::ContentSubscription> - gateway_status_subs; - - Governor governor; - - // only one of these will actually be in use. This is messy but expedient - // in that it minimizes the modifications to existing FIX generation code - jetfix::OutFIXPtr buffered_fix_msgs; - std::vector buffered_order_msgs; - - trace::CorID current_trace; - std::unique_ptr gw; - mercury::Stream exe_report_pub; - mercury::Stream gw_status_change_pub; - mercury::Stream cancel_reject_pub; - mercury::Stream exchange_position_pub; - mercury::Stream exchange_open_ordes_pub; -}; - class OrderServicesData { public: OrderServicesData( OrderManager &owner, DynamicOrderRegistry const &b, trace::PerfLog &l, - md::SecurityOracle); + md::SecurityOracle, + std::vector gateways); OrderManager &owner; trace::PerfLog &log; diff --git a/src/lib/orderman/actors/order_manager/order_gateway_definition.h b/src/lib/orderman/actors/order_manager/order_gateway_definition.h new file mode 100644 index 000000000..ca1529c74 --- /dev/null +++ b/src/lib/orderman/actors/order_manager/order_gateway_definition.h @@ -0,0 +1,15 @@ +#pragma once + +#include "lib/config/protos/jetfix.pb.h" +#include "lib/orderman/gateways/IExecutionGateway.h" + +#include + +namespace bts::orderman { + +struct OrderGatewayDefinition { + std::shared_ptr gateway; + config::JetFIX_Connection connection; +}; + +} // namespace bts::orderman diff --git a/src/lib/orderman/actors/order_manager/session_services_data.h b/src/lib/orderman/actors/order_manager/session_services_data.h new file mode 100644 index 000000000..e207a2882 --- /dev/null +++ b/src/lib/orderman/actors/order_manager/session_services_data.h @@ -0,0 +1,61 @@ +#pragma once + +#include "lib/logging/logging.h" +#include "lib/mercury/actors/ContentSubscription.h" +#include "lib/mercury/events/Stream.h" +#include "lib/orderman/Governor.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/events/CancelRejectEvent.h" +#include "lib/orderman/events/ExchangeOpenOrdersEvent.h" +#include "lib/orderman/events/ExchangePositionEvent.h" +#include "lib/orderman/events/GatewayStatusChangeEvent.h" +#include "lib/orderman/events/NewExecutionReportEvent.h" +#include "lib/orderman/gateways/ExecutionGatewayFactory.h" +#include "lib/orderman/gateways/IExecutionGateway.h" +#include "lib/utils/PBUtils.h" + +#include +#include + +namespace bts::orderman { + +struct SessionServicesData { + SessionServicesData(OrderGatewayDefinition gw_def) + : session(gw_def.connection.name()), gw_connected(false), + cfg(gw_def.connection), + governor(cfg.max_order_msgs_per_window(), cfg.window_duration_msecs()), + gw(gw_def.gateway) { + buffered_order_msgs.reserve(1000); + LOG(OrderMan, Info, "SessionServicesData::SessionServicesData cfg: {}", + utils::pb::to_string(cfg)); + } + + std::string session; + std::vector free_buffers; + bool gw_connected; + config::JetFIX::Connection cfg; + std::unique_ptr> + exe_report_subs; + std::unique_ptr> + cancel_reject_subs; + std::unique_ptr< + mercury::ContentSubscription> + gateway_status_subs; + + Governor governor; + + // only one of these will actually be in use. This is messy but expedient + // in that it minimizes the modifications to existing FIX generation code + jetfix::OutFIXPtr buffered_fix_msgs; + std::vector buffered_order_msgs; + + trace::CorID current_trace; + std::shared_ptr gw; + mercury::Stream exe_report_pub; + mercury::Stream gw_status_change_pub; + mercury::Stream cancel_reject_pub; + mercury::Stream exchange_position_pub; + mercury::Stream exchange_open_ordes_pub; +}; + +} // namespace bts::orderman diff --git a/src/lib/orderman/gateways/IExecutionGateway.cpp b/src/lib/orderman/gateways/IExecutionGateway.cpp new file mode 100644 index 000000000..7db77a9c6 --- /dev/null +++ b/src/lib/orderman/gateways/IExecutionGateway.cpp @@ -0,0 +1,7 @@ +#include "IExecutionGateway.h" + +namespace bts::orderman { + +IExecutionGateway::~IExecutionGateway() = default; + +} // namespace bts::orderman diff --git a/src/lib/orderman/gateways/IExecutionGateway.h b/src/lib/orderman/gateways/IExecutionGateway.h index ba5fb366e..086b61679 100644 --- a/src/lib/orderman/gateways/IExecutionGateway.h +++ b/src/lib/orderman/gateways/IExecutionGateway.h @@ -39,8 +39,15 @@ using OnExchangeOpenOrdersState = class IExecutionGateway { public: IExecutionGateway() = default; - virtual ~IExecutionGateway() {} + virtual ~IExecutionGateway(); + virtual bool has_name() const { + return false; + } + virtual const std::string &get_name() const { + static std::string default_name; + return default_name; + } virtual void start() = 0; virtual void dispatch_incoming_fix_messages() = 0; virtual void on_securities(const mercury::Update &) = 0; diff --git a/src/lib/orderman/gateways/execution_gateway_provider.cpp b/src/lib/orderman/gateways/execution_gateway_provider.cpp new file mode 100644 index 000000000..b68d14f8a --- /dev/null +++ b/src/lib/orderman/gateways/execution_gateway_provider.cpp @@ -0,0 +1,31 @@ +#include "execution_gateway_provider.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/gateways/ExecutionGatewayFactory.h" + +namespace bts::orderman { + +struct ExecutionGatewayProvider::PImpl { + PImpl(trace::PerfLog *l, md::SecurityOracle o) : l(l), o(std::move(o)) {} + + trace::PerfLog *l; + md::SecurityOracle o; +}; + +ExecutionGatewayProvider::ExecutionGatewayProvider( + trace::PerfLog *l, md::SecurityOracle o) + : me_(std::make_unique(l, std::move(o))) {} + +ExecutionGatewayProvider::~ExecutionGatewayProvider() = default; + +std::vector ExecutionGatewayProvider::create() { + auto conns = config::get().connection(); + std::vector gateways; + for (auto c : conns) { + auto &gw = gateways.emplace_back(); + gw.connection = std::move(c); + gw.gateway = ExecutionGatewayFactory::create_gateway(c, *me_->l, me_->o); + } + return gateways; +} + +} // namespace bts::orderman diff --git a/src/lib/orderman/gateways/execution_gateway_provider.h b/src/lib/orderman/gateways/execution_gateway_provider.h new file mode 100644 index 000000000..9eeb3b1ff --- /dev/null +++ b/src/lib/orderman/gateways/execution_gateway_provider.h @@ -0,0 +1,22 @@ +#pragma once + +#include "lib/orderman/gateways/i_execution_gateway_provider.h" + +#include +#include + +namespace bts::orderman { + +class ExecutionGatewayProvider : public IExecutionGatewayProvider { + public: + ExecutionGatewayProvider(trace::PerfLog *l, md::SecurityOracle o); + ~ExecutionGatewayProvider() override; + + std::vector create() override; + + private: + struct PImpl; + std::unique_ptr me_; +}; + +} // namespace bts::orderman diff --git a/src/lib/orderman/gateways/i_execution_gateway_provider.cpp b/src/lib/orderman/gateways/i_execution_gateway_provider.cpp new file mode 100644 index 000000000..3826c505b --- /dev/null +++ b/src/lib/orderman/gateways/i_execution_gateway_provider.cpp @@ -0,0 +1,7 @@ +#include "i_execution_gateway_provider.h" + +namespace bts::orderman { + +IExecutionGatewayProvider::~IExecutionGatewayProvider() = default; + +} // namespace bts::orderman diff --git a/src/lib/orderman/gateways/i_execution_gateway_provider.h b/src/lib/orderman/gateways/i_execution_gateway_provider.h new file mode 100644 index 000000000..afc94d09e --- /dev/null +++ b/src/lib/orderman/gateways/i_execution_gateway_provider.h @@ -0,0 +1,17 @@ +#pragma once + +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" + +#include + +namespace bts::orderman { + +class IExecutionGatewayProvider { + public: + IExecutionGatewayProvider() = default; + virtual ~IExecutionGatewayProvider(); + + virtual std::vector create() = 0; +}; + +} // namespace bts::orderman diff --git a/src/lib/orderman/orders/EMNativeOrder.cpp b/src/lib/orderman/orders/EMNativeOrder.cpp index 088608d96..696bcbca6 100644 --- a/src/lib/orderman/orders/EMNativeOrder.cpp +++ b/src/lib/orderman/orders/EMNativeOrder.cpp @@ -520,6 +520,9 @@ OrderOpResult EMNativeOrder::_on_activate( case api::VENUE_OKX: session_name="okx_1"; break; + case api::VENUE_BINANCE_USDS_FUTURES: + session_name = "binance_usds_futures_1"; + break; default: session_name ="deribit_1"; @@ -801,4 +804,4 @@ void EMNativeOrder::_absorb_fill(const ExecutionReport &er) { } } // namespace orderman -} // namespace bts \ No newline at end of file +} // namespace bts diff --git a/src/lib/utils/checked_arithmetic.h b/src/lib/utils/checked_arithmetic.h index 91e60a6b9..dc42c4b45 100644 --- a/src/lib/utils/checked_arithmetic.h +++ b/src/lib/utils/checked_arithmetic.h @@ -6,8 +6,11 @@ namespace bts::system::math { -static std::uint32_t checked_ltou(std::int64_t l); -static std::uint64_t checked_ltoul(std::int64_t l); +std::uint32_t checked_ltou(std::int64_t l); +std::uint64_t checked_ltoul(std::int64_t l); +bool checked_ltou(std::int64_t l, std::uint32_t &res); +bool checked_ltoul(std::int64_t l, std::uint64_t &res); +bool checked_ultol(std::uint64_t l, std::int64_t &res); ////////////////////////////////////////////////// // Definition @@ -34,4 +37,30 @@ inline std::uint64_t checked_ltoul(std::int64_t l) { return static_cast(l); } +inline bool checked_ltou(std::int64_t l, std::uint32_t &res) { + if (l < 0 || l > static_cast( + std::numeric_limits::max())) { + return false; + } + res = static_cast(l); + return true; +} + +inline bool checked_ltoul(std::int64_t l, std::uint64_t &res) { + if (l < 0) { + return false; + } + res = static_cast(l); + return true; +} + +inline std::int64_t checked_ultol(std::uint64_t ul) { + if (ul > + static_cast(std::numeric_limits::max())) { + throw std::overflow_error{ + "Failed to convert uint64 to int64 (value > max)"}; + } + return static_cast(ul); +} + } // namespace bts::system::math diff --git a/src/lib/utils/crypto/hmac.cpp b/src/lib/utils/crypto/hmac.cpp new file mode 100644 index 000000000..ba54a9c8a --- /dev/null +++ b/src/lib/utils/crypto/hmac.cpp @@ -0,0 +1,44 @@ +#include "hmac.h" + +#include +#include +#include + +namespace bts::system::crypto { + +static std::string to_hex(const unsigned char *data, size_t length) { + std::ostringstream oss; + oss << std::hex << std::setfill('0'); + for (size_t i = 0; i < length; ++i) { + oss << std::setw(2) << static_cast(data[i]); + } + return oss.str(); +} + +bool hmac_digest( + const std::string &secret, + const std::string &message, + unsigned char **bytes, + unsigned int *result_len) { + *bytes = HMAC( + EVP_sha256(), // Hash function + secret.c_str(), secret.size(), // Key + reinterpret_cast(message.c_str()), + message.size(), // Data + nullptr, result_len // Output buffer and result length + ); + return true; +} + +bool hmac_digest_hex( + const std::string &secret, + const std::string &message, + std::string &result_hex) { + unsigned char *bytes; + unsigned int result_len; + hmac_digest(secret, message, &bytes, &result_len); + result_hex = to_hex(bytes, result_len); + return true; +} + +} // namespace bts::system::crypto diff --git a/src/lib/utils/crypto/hmac.h b/src/lib/utils/crypto/hmac.h new file mode 100644 index 000000000..72c4124bd --- /dev/null +++ b/src/lib/utils/crypto/hmac.h @@ -0,0 +1,18 @@ +#pragma once + +#include + +namespace bts::system::crypto { + +bool hmac_digest( + const std::string &secret, + const std::string &message, + unsigned char **bytes, + unsigned int *result_len); + +bool hmac_digest_hex( + const std::string &secret, + const std::string &message, + std::string &result_hex); + +} // namespace bts::system::crypto diff --git a/src/lib/utils/file_utils.cpp b/src/lib/utils/file_utils.cpp index dfa943533..9bbc3ac37 100644 --- a/src/lib/utils/file_utils.cpp +++ b/src/lib/utils/file_utils.cpp @@ -26,5 +26,22 @@ std::string normalize_data_path(std::string const &input_path) { return input_path; } +std::string read_file(const std::string &path) { + std::string out; + read_file(path, out); + return out; +} + +void read_file(const std::string &path, std::string &out) { + std::ifstream ifstr{path}; + // Preallocate memory + ifstr.seekg(0, std::ios::end); + out.reserve(ifstr.tellg()); + ifstr.seekg(0, std::ios::beg); + out.assign( + (std::istreambuf_iterator(ifstr)), + std::istreambuf_iterator()); +} + } // namespace utils } // namespace bts diff --git a/src/lib/utils/file_utils.h b/src/lib/utils/file_utils.h index 19b890b5b..bef7f93dc 100644 --- a/src/lib/utils/file_utils.h +++ b/src/lib/utils/file_utils.h @@ -6,5 +6,9 @@ namespace bts { namespace utils { std::string normalize_data_path(std::string const &input_path); bool create_if_not_there(std::string const &path); + +std::string read_file(const std::string &path); +void read_file(const std::string &path, std::string &out); + } // namespace utils } // namespace bts diff --git a/src/lib/utils/string_utils.h b/src/lib/utils/string_utils.h new file mode 100644 index 000000000..3cc2aa6b4 --- /dev/null +++ b/src/lib/utils/string_utils.h @@ -0,0 +1,86 @@ +#pragma once + +#include +#include + +namespace bts::system::string_utils { + +template +bool copy_to_array( + const std::string &src, + std::array &dest, + bool null_terminate = true); + +template +bool parse_uint(const std::string &s, UIntType &i); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +template +bool copy_to_array( + const std::string &src, std::array &dest, bool null_terminate) { + std::size_t i = 0; + auto sz = dest.size(); + if (null_terminate) { + sz--; + } + if (src.size() < sz) { + sz = src.size(); + } + for (; i < sz; i++) { + dest[i] = src.at(i); + } + if (null_terminate) { + dest[sz] = '\0'; + } + return src.size() < dest.size() || + (!null_terminate && src.size() == dest.size()); +} + +template +inline bool parse_uint(const std::string &s, UIntType &i) { + i = 0; + const auto sz = s.size(); + int pow10 = 1; + for (std::size_t n = 0; n < sz; n++) { + switch (s[sz - n - 1]) { + case '0': + break; + case '1': + i += pow10; + break; + case '2': + i += 2 * pow10; + break; + case '3': + i += 3 * pow10; + break; + case '4': + i += 4 * pow10; + break; + case '5': + i += 5 * pow10; + break; + case '6': + i += 6 * pow10; + break; + case '7': + i += 7 * pow10; + break; + case '8': + i += 8 * pow10; + break; + case '9': + i += 9 * pow10; + break; + default: + return false; + } + pow10 *= 10; + } + return true; +} + +} // namespace bts::system::string_utils diff --git a/src/lib_binance_execution/CMakeLists.txt b/src/lib_binance_execution/CMakeLists.txt new file mode 100644 index 000000000..165951d9d --- /dev/null +++ b/src/lib_binance_execution/CMakeLists.txt @@ -0,0 +1,17 @@ +cmake_minimum_required(VERSION 3.23) +project(binance_execution) + +file( + GLOB_RECURSE ${PROJECT_NAME}_SOURCES + RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} + *.cpp) + +add_library(${PROJECT_NAME} STATIC ${${PROJECT_NAME}_SOURCES}) + +target_include_directories( + ${PROJECT_NAME} + PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} +) + +target_link_libraries(${PROJECT_NAME} PUBLIC libspark) diff --git a/src/lib_binance_execution/binance_execution/enums/event_reason_type.h b/src/lib_binance_execution/binance_execution/enums/event_reason_type.h new file mode 100644 index 000000000..a3a4068a1 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/event_reason_type.h @@ -0,0 +1,44 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(EventReasonType, NONE) \ + per_value(EventReasonType, DEPOSIT) \ + per_value(EventReasonType, WITHDRAW) \ + per_value(EventReasonType, ORDER) \ + per_value(EventReasonType, FUNDING_FEE) \ + per_value(EventReasonType, WITHDRAW_REJECT) \ + per_value(EventReasonType, ADJUSTMENT) \ + per_value(EventReasonType, INSURANCE_CLEAR) \ + per_value(EventReasonType, ADMIN_DEPOSIT) \ + per_value(EventReasonType, ADMIN_WITHDRAW) \ + per_value(EventReasonType, MARGIN_TRANSFER) \ + per_value(EventReasonType, MARGIN_TYPE_CHANGE) \ + per_value(EventReasonType, ASSET_TRANSFER) \ + per_value(EventReasonType, OPTIONS_PREMIUM_FEE) \ + per_value(EventReasonType, OPTIONS_SETTLE_PROFIT) \ + per_value(EventReasonType, AUTO_EXCHANGE) \ + per_value(EventReasonType, COIN_SWAP_DEPOSIT) \ + per_value(EventReasonType, COIN_SWAP_WITHDRAW) +// clang-format on + +/** + * @brief Represents the different Event Reason Types at Binance + * + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams/Event-Balance-and-Position-Update + */ +ENUM_CLASS_DEF(EventReasonType, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::EventReasonType, t, "{}", t.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/execution_type.h b/src/lib_binance_execution/binance_execution/enums/execution_type.h new file mode 100644 index 000000000..72a4e73ea --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/execution_type.h @@ -0,0 +1,32 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(ExecutionType, NONE) \ + per_value(ExecutionType, NEW) \ + per_value(ExecutionType, CANCELED) \ + per_value(ExecutionType, REPLACED) \ + per_value(ExecutionType, REJECTED) \ + per_value(ExecutionType, TRADE) \ + per_value(ExecutionType, EXPIRED) \ + per_value(ExecutionType, TRADE_PREVENTION) +// clang-format on + +/** + * @brief Represents the different execution types at Binance + */ +ENUM_CLASS_DEF(ExecutionType, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::ExecutionType, t, "{}", t.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/order_status.h b/src/lib_binance_execution/binance_execution/enums/order_status.h new file mode 100644 index 000000000..5716139af --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/order_status.h @@ -0,0 +1,34 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(OrderStatus, NONE) \ + per_value(OrderStatus, NEW) \ + per_value(OrderStatus, PENDING_NEW) \ + per_value(OrderStatus, PARTIALLY_FILLED) \ + per_value(OrderStatus, FILLED) \ + per_value(OrderStatus, CANCELED) \ + per_value(OrderStatus, PENDING_CANCEL) \ + per_value(OrderStatus, REJECTED) \ + per_value(OrderStatus, EXPIRED) \ + per_value(OrderStatus, EXPIRED_IN_MATCH) +// clang-format on + +/** + * @brief Represents the different order statuses at Binance + */ +ENUM_CLASS_DEF(OrderStatus, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::OrderStatus, t, "{}", t.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/order_type.h b/src/lib_binance_execution/binance_execution/enums/order_type.h new file mode 100644 index 000000000..a753f15e0 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/order_type.h @@ -0,0 +1,27 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(OrderType, NONE) \ + per_value(OrderType, LIMIT) \ + per_value(OrderType, MARKET) +// clang-format on + +/** + * @brief Represents the different order types at Binance + */ +ENUM_CLASS_DEF(OrderType, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::OrderType, t, "{}", t.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/position_side.h b/src/lib_binance_execution/binance_execution/enums/position_side.h new file mode 100644 index 000000000..2a8bdef61 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/position_side.h @@ -0,0 +1,25 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution::usds_futures { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(PositionSide, NONE) \ + per_value(PositionSide, LONG) \ + per_value(PositionSide, SHORT) \ + per_value(PositionSide, BOTH) +// clang-format on + +ENUM_CLASS_DEF(PositionSide, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution::usds_futures + +FMT_IMPL(binance_execution::usds_futures::PositionSide, s, "{}", s.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/price_match_mode.h b/src/lib_binance_execution/binance_execution/enums/price_match_mode.h new file mode 100644 index 000000000..1aae2baf7 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/price_match_mode.h @@ -0,0 +1,30 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(PriceMatchMode, NONE) \ + per_value(PriceMatchMode, OPPONENT) \ + per_value(PriceMatchMode, OPPONENT_5) \ + per_value(PriceMatchMode, OPPONENT_10) \ + per_value(PriceMatchMode, OPPONENT_20) \ + per_value(PriceMatchMode, QUEUE) \ + per_value(PriceMatchMode, QUEUE_5) \ + per_value(PriceMatchMode, QUEUE_10) \ + per_value(PriceMatchMode, QUEUE_20) +// clang-format on + +ENUM_CLASS_DEF(PriceMatchMode, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::PriceMatchMode, m, "{}", m.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/self_trade_prevention_mode.h b/src/lib_binance_execution/binance_execution/enums/self_trade_prevention_mode.h new file mode 100644 index 000000000..2fbb6ff7f --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/self_trade_prevention_mode.h @@ -0,0 +1,22 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(SelfTradePreventionMode, NONE) +// clang-format on + +ENUM_CLASS_DEF(SelfTradePreventionMode, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::SelfTradePreventionMode, m, "{}", m.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/side.h b/src/lib_binance_execution/binance_execution/enums/side.h new file mode 100644 index 000000000..2933eea86 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/side.h @@ -0,0 +1,24 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(Side, NONE) \ + per_value(Side, BUY) \ + per_value(Side, SELL) +// clang-format on + +ENUM_CLASS_DEF(Side, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::Side, s, "{}", s.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/time_in_force.h b/src/lib_binance_execution/binance_execution/enums/time_in_force.h new file mode 100644 index 000000000..ab6ebd53c --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/time_in_force.h @@ -0,0 +1,30 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(TimeInForce, NONE) \ + per_value(TimeInForce, GTC) \ + per_value(TimeInForce, IOC) \ + per_value(TimeInForce, FOK) \ + per_value(TimeInForce, GTX) \ + per_value(TimeInForce, GTD) +// clang-format on + +/** + * @brief Represents the different TimeInForce types at Binance + */ +ENUM_CLASS_DEF(TimeInForce, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::TimeInForce, t, "{}", t.name()); diff --git a/src/lib_binance_execution/binance_execution/enums/working_type.h b/src/lib_binance_execution/binance_execution/enums/working_type.h new file mode 100644 index 000000000..0a4886c67 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/enums/working_type.h @@ -0,0 +1,23 @@ +#pragma once + +#include "lib/core/EnumMacros.h" +#include "lib/core/FMT_IMPL.h" + +#include +#include + +namespace binance_execution { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(WorkingType, NONE) \ + per_value(WorkingType, CONTRACT_PRICE) +// clang-format on + +ENUM_CLASS_DEF(WorkingType, FOR_ALL_VALUES) + +#undef FOR_ALL_VALUES + +} // namespace binance_execution + +FMT_IMPL(binance_execution::WorkingType, t, "{}", t.name()); diff --git a/src/lib_binance_execution/binance_execution/execution_gateway_provider.cpp b/src/lib_binance_execution/binance_execution/execution_gateway_provider.cpp new file mode 100644 index 000000000..2de20c5a5 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/execution_gateway_provider.cpp @@ -0,0 +1,40 @@ +#include "execution_gateway_provider.h" +#include "binance_execution/usds_futures/execution_gateway.h" +#include "lib/domain_model/Security.pb.h" +#include "lib/md/SecurityOracle.h" +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/gateways/ExecutionGatewayFactory.h" +#include "lib/os/spark_data_directory.h" + +namespace binance_execution { + +struct ExecutionGatewayProvider::PImpl { + PImpl(bts::md::SecurityOracle sec_oracle) + : sec_oracle(std::move(sec_oracle)) {} + + bts::md::SecurityOracle sec_oracle; +}; + +ExecutionGatewayProvider::ExecutionGatewayProvider( + bts::md::SecurityOracle sec_oracle) + : me_(std::make_unique(std::move(sec_oracle))) {} + +ExecutionGatewayProvider::~ExecutionGatewayProvider() = default; + +std::vector +ExecutionGatewayProvider::create() { + std::vector gws; + bts::spark::SparkDataDirectory data_dir; + usds_futures::ExecutionGatewayConfig usds_futures_cfg; + if (data_dir.load_config_json( + "binance_usds_futures_execution", usds_futures_cfg)) { + auto &binance_gw = gws.emplace_back(); + *binance_gw.connection.mutable_name() = "binance_usds_futures_1"; + binance_gw.connection.set_venue(bts::api::VENUE_BINANCE_USDS_FUTURES); + binance_gw.gateway = std::make_shared( + me_->sec_oracle, usds_futures_cfg, binance_gw.connection.name()); + } + return gws; +} + +} // namespace binance_execution diff --git a/src/lib_binance_execution/binance_execution/execution_gateway_provider.h b/src/lib_binance_execution/binance_execution/execution_gateway_provider.h new file mode 100644 index 000000000..2086ba5ea --- /dev/null +++ b/src/lib_binance_execution/binance_execution/execution_gateway_provider.h @@ -0,0 +1,24 @@ +#pragma once + +#include "lib/orderman/actors/order_manager/order_gateway_definition.h" +#include "lib/orderman/gateways/i_execution_gateway_provider.h" + +#include +#include + +namespace binance_execution { + +class ExecutionGatewayProvider + : public bts::orderman::IExecutionGatewayProvider { + public: + explicit ExecutionGatewayProvider(bts::md::SecurityOracle sec_oracle); + ~ExecutionGatewayProvider() override; + + std::vector create() override; + + private: + struct PImpl; + std::unique_ptr me_; +}; + +} // namespace binance_execution diff --git a/src/lib_binance_execution/binance_execution/price.h b/src/lib_binance_execution/binance_execution/price.h new file mode 100644 index 000000000..31223c57c --- /dev/null +++ b/src/lib_binance_execution/binance_execution/price.h @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +namespace binance_execution { + +void price_to_string( + double value, + std::string &dest, + int n_decimals = 4, + std::size_t capacity = 24); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void price_to_string( + double value, std::string &dest, int n_decimals, std::size_t capacity) { + const std::size_t orig_sz = dest.size(); + dest.resize(orig_sz + capacity); + char *buffer = &dest[orig_sz]; + auto [ptr, ec] = std::to_chars( + buffer, buffer + capacity, value, std::chars_format::fixed, n_decimals); + if (ec != std::errc{}) { + // Formatting failed + dest.resize(orig_sz); + return; + } + // Resize to the actual formatted length + dest.resize(orig_sz + (ptr - buffer)); + // Remove trailing zeros + dest.erase(dest.find_last_not_of('0') + 1); + // Remove trailing decimal point if necessary + if (!dest.empty() && dest.back() == '.') { + dest.pop_back(); + } +} + +} // namespace binance_execution diff --git a/src/lib_binance_execution/binance_execution/quantity.h b/src/lib_binance_execution/binance_execution/quantity.h new file mode 100644 index 000000000..971dca28e --- /dev/null +++ b/src/lib_binance_execution/binance_execution/quantity.h @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +namespace binance_execution { + +void quantity_to_string( + double value, + std::string &dest, + int n_decimals = 4, + std::size_t capacity = 24); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void quantity_to_string( + double value, std::string &dest, int n_decimals, std::size_t capacity) { + const std::size_t orig_sz = dest.size(); + dest.resize(orig_sz + capacity); + char *buffer = &dest[orig_sz]; + auto [ptr, ec] = std::to_chars( + buffer, buffer + capacity, value, std::chars_format::fixed, n_decimals); + if (ec != std::errc{}) { + // Formatting failed + dest.resize(orig_sz); + return; + } + // Resize to the actual formatted length + dest.resize(orig_sz + (ptr - buffer)); + // Remove trailing zeros + dest.erase(dest.find_last_not_of('0') + 1); + // Remove trailing decimal point if necessary + if (!dest.empty() && dest.back() == '.') { + dest.pop_back(); + } +} + +} // namespace binance_execution diff --git a/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.cpp b/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.cpp new file mode 100644 index 000000000..8ef7b9dcc --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.cpp @@ -0,0 +1,405 @@ +#include "execution_gateway.h" +#include "binance_execution/usds_futures/messages/create_order_response.h" +#include "binance_execution/usds_futures/messages/modify_order_request.h" +#include "binance_execution/usds_futures/rest_api_client.h" +#include "binance_execution/usds_futures/rest_api_result.h" +#include "binance_execution/usds_futures/type_converters.h" +#include "binance_execution/usds_futures/user_data_streams/listen_key_requestor.h" +#include "binance_execution/usds_futures/user_data_streams/user_data_subscription.h" +#include "lib/api/service_helpers/AdminServiceUtils.h" +#include "lib/api/services/AdminService.pb.h" +#include "lib/config/protos/jetfix.pb.h" +#include "lib/config/protos/toggles.pb.h" +#include "lib/core/TimeStamp.h" +#include "lib/domain_model/Security.h" +#include "lib/domain_model/Security.pb.h" +#include "lib/md/SecurityOracle.h" +#include "lib/mercury/events/Update.h" +#include "lib/orderman/CancelOrderMsg.h" +#include "lib/orderman/CancelReplaceOrderMsg.h" +#include "lib/orderman/CreateOrderMsg.h" +#include "lib/orderman/RFQMsg.h" +#include "lib/orderman/events/NewAdminDataEvent.h" +#include "lib/orderman/events/NewSecuritiesEvent.h" +#include "lib/orderman/orderman_utils/ExchangePosition.h" +#include "lib/orderman/orderman_utils/ExecutionReport.h" +#include "lib/orderman/orderman_utils/orderman_common.h" +#include "lib/utils/checked_arithmetic.h" +#include "lib/utils/overloaded.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +using nlohmann::json; + +namespace binance_execution::usds_futures { + +#define _LOG_FN(level, fn, ...) \ + LOG(OrderMan, level, "ExecutionGateway::" fn ". " __VA_ARGS__) +#define INFO_FN(fn, ...) _LOG_FN(bts::Info, fn, __VA_ARGS__) +#define WARN_FN(fn, ...) _LOG_FN(bts::Warn, fn, __VA_ARGS__) +#define ERROR_FN(fn, ...) _LOG_FN(bts::Error, fn, __VA_ARGS__) + +#define VENUE bts::api::VENUE_BINANCE_USDS_FUTURES + +using boost::object_pool; +using boost::lockfree::spsc_queue; +using bts::core::Delegate; +using bts::orderman::CancelOrderMsg; +using bts::orderman::CancelReplaceOrderMsg; +using bts::orderman::CreateOrderMsg; +using bts::orderman::NewAdminDataEvent; +using bts::orderman::NewSecuritiesEvent; +using bts::orderman::OrderMsg; +using bts::orderman::RFQMsg; +using std::int64_t; +using std::optional; +using std::size_t; +using std::string; +using std::uint32_t; +using std::unordered_map; +using std::vector; + +struct ExecutionGatewayCallbacks { + bts::orderman::OnExeReport exe_report; + bts::orderman::OnGwStatusChange gw_status_change; + bts::orderman::OnCancelReject cancel_reject; + bts::orderman::OnExchangePositionState exchange_position_state; + bts::orderman::OnExchangeOpenOrdersState exchange_open_orders; +}; + +struct ExecutionGateway::PImpl { + explicit PImpl( + bts::md::SecurityOracle sec_oracle, + ExecutionGatewayConfig config, + string session_name) + : sec_oracle(std::move(sec_oracle)), config(std::move(config)), + rest_api_client( + this->config.rest_endpoint, + this->config.api_key, + this->config.secret_key), + listen_key_requestor(this->rest_api_client) { + jetfix_connection.set_venue(bts::api::VENUE_BINANCE_USDS_FUTURES); + *jetfix_connection.mutable_name() = std::move(session_name); + pos.exchange = bts::api::VENUE_BINANCE_USDS_FUTURES; + } + + bts::md::SecurityOracle sec_oracle; + ExecutionGatewayConfig config; + bts::config::JetFIX_Connection jetfix_connection; + + unordered_map> response_handlers; + RestApiClient rest_api_client; + optional user_data_sub; + Delegate account_update_callback; + Delegate order_update_callback; + ListenKeyRequestor listen_key_requestor; + + spsc_queue incoming_msgs{1024}; + spsc_queue incoming_account_updates{1024}; + spsc_queue incoming_order_updates{1024}; + spsc_queue> incoming_new_orders{1024}; + + object_pool exe_report_pool; + vector account_updates_vec; + + ExecutionGatewayCallbacks callbacks; + bts::orderman::ExchangePosition pos; + bts::admin::AdminServiceUtils::ExchangeSubAccountResolver + subaccount_resolver{}; + bts::api::admin::AdminData admin_data = {}; + bts::api::admin::BTSAccount account; + + void start() { + listen_key_requestor.callback().bind<&PImpl::on_listen_key_>(*this); + listen_key_requestor.start(); + } + + void stop() { user_data_sub.reset(); } + + void on_account_update(user_data_streams::AccountUpdate u) { + incoming_account_updates.push(u); + } + + void on_order_update(user_data_streams::OrderUpdate u) { + incoming_order_updates.push(u); + } + + void on_listen_key_(const string &listen_key) { + user_data_sub.reset(); + if (listen_key.empty()) { + LOG(OrderMan, bts::Error, + "Unable to subscribe to user data because 'listen_key' " + "is empty."); + return; + } + auto &uds = user_data_sub.emplace( + config.ws_stream_endpoint + "/ws/" + listen_key); + uds.account_update_callback().bind<&PImpl::on_account_update>(*this); + uds.order_update_callback().bind<&PImpl::on_order_update>(*this); + uds.start(); + } + + void create_order(const CreateOrderMsg &m) { + if (m.security == nullptr) { + ERROR_FN("send_order", "CreateOrderMsg security is nullptr"); + incoming_new_orders.push( + RestApiResult::from_error( + "security is nullptr")); + return; + } + bts_assert(m.security->exchange() == VENUE); + if (!m.security->has_binance_usds_futures()) { + ERROR_FN( + "send_order", + "CreateOrderMsg security not of Binance Usds Futures"); + incoming_new_orders.push( + RestApiResult::from_error( + "security not of Binance Usds Futures")); + return; + } + if (m.quantity == 0) { + ERROR_FN("send_order", "CreateOrderMsg quantity is 0"); + incoming_new_orders.push( + RestApiResult::from_error("quantity is 0")); + return; + } + CreateOrderRequest req; + req.newClientOrderId = std::to_string(m.key.value()); + req.symbol = bts::securities::descriptor(*m.security); + req.side = m.side == bts::api::SIDE_BUY ? Side::BUY : Side::SELL; + req.price = m.price.value(); + req.quantity = m.quantity.full_value(); + req.type = convert_order_type(m.order_type); + req.timeInForce = convert_time_in_force(m.time_in_force); + req.timestamp = convert_time_stamp(bts::core::TimeStamp::now()); + auto res = rest_api_client.create_order(req); + if (!res.ok()) { + ERROR_FN("send_order", "Send order failed. err: {}", res.error); + } + incoming_new_orders.push(res); + } + + void update_order(const CancelReplaceOrderMsg &m) { + ModifyOrderRequest req; + req.orderId = + bts::system::math::checked_ultol(m.exchange_order_id.value()); + req.origClientOrderId = std::to_string(m.create_fields.key.value()); + req.price = m.create_fields.price.value(); + req.priceMatch = PriceMatchMode::NONE; + req.quantity = m.create_fields.quantity.full_value(); + req.symbol = + m.create_fields.security->binance_usds_futures().security_desc(); + req.side = convert_side(m.create_fields.side); + req.timestamp = convert_time_stamp(bts::core::TimeStamp::now()); + const auto res = rest_api_client.modify_order(req); + if (!res.ok()) { + ERROR_FN( + "update_order", "ord_id: {}; err: {}", req.orderId, res.error); + } + } + + void cancel_order(const CancelOrderMsg &m) { + CancelOrderRequest req; + req.orderId = + bts::system::math::checked_ultol(m.exchange_order_id.value()); + req.origClientOrderId = std::to_string(m.key.value()); + req.symbol = m.security->binance_usds_futures().security_desc(); + req.timestamp = convert_time_stamp(bts::core::TimeStamp::now()); + const auto res = rest_api_client.cancel_order(req); + if (!res.ok()) { + ERROR_FN( + "cancel_order", "ord_id: {}; err: {}", req.orderId, res.error); + } + } +}; + +ExecutionGateway::ExecutionGateway( + bts::md::SecurityOracle sec_oracle, + ExecutionGatewayConfig session_cfg, + string session_name) + : me_(std::make_unique( + std::move(sec_oracle), + std::move(session_cfg), + std::move(session_name))) { + bts_assert( + me_->config.account.size() <= + bts::orderman::ExecutionReport{}.account_name.value().size()); +} + +ExecutionGateway::~ExecutionGateway() = default; + +void ExecutionGateway::start() { me_->start(); } + +void ExecutionGateway::on_securities( + const bts::mercury::Update & /*update*/) { + INFO_FN( + "on_securities", "t_id: {} t_name: {}", bts::os::get_thread_id(), + bts::os::get_thread_name()); +} + +void ExecutionGateway::on_admin_data( + const bts::mercury::Update &update) { + INFO_FN( + "on_admin_data", "t_id: {} t_name: {}", bts::os::get_thread_id(), + bts::os::get_thread_name()); + if (update.events == nullptr) { + return; + } + for (const auto &ev : *(update.events)) { + me_->admin_data.CopyFrom(*ev.admin_data); + } + auto *exch_sub_acct = + me_->subaccount_resolver.find_entry(me_->config.account, false); + if (exch_sub_acct == nullptr) { + WARN_FN( + "on_admin_data", + "Failed to map exchange account '{}' to internal account", + me_->config.account); + return; + } + auto *account = bts::admin::AdminServiceUtils::find_account( + me_->admin_data, exch_sub_acct->bts_account_name()); + if (account == nullptr) { + WARN_FN( + "on_admin_data", + "Failed to find internal account '{}' (mapped from exchange account " + "'{}')", + exch_sub_acct->bts_account_name(), me_->config.account); + return; + } + if (me_->account.name() == account->name() && + me_->account.id() == account->id()) { + return; + } + me_->account = *account; + INFO_FN( + "on_admin_data", "bts_account: {}; exch_subaccount: {}", account->name(), + exch_sub_acct->exchange_subaccount()); +} + +void ExecutionGateway::send_msgs( + vector const &msg_vec, bts::trace::CorID) { + INFO_FN("send_msgs", "count: {}", msg_vec.size()); + for (const auto &msg : msg_vec) { + std::visit( + bts::overloaded{ + [&](const CreateOrderMsg &m) { me_->create_order(m); }, + [&](const CancelReplaceOrderMsg &m) { me_->update_order(m); }, + [&](const CancelOrderMsg &m) { me_->cancel_order(m); }, + [&](const RFQMsg &) { + bts_assert_msg(false, "Binance RFQ not implemented"); + }, + }, + msg); + } +} + +void ExecutionGateway::send_fix( + const bts::jetfix::OutFIXPtr &, bts::trace::CorID) { + bts_assert_msg(false, "ExecutionGateway does not support fix"); +} + +void ExecutionGateway::dispatch_incoming_fix_messages() { + static constexpr const bool IGNORE_CREATE_ORDER_RESPONSE = true; + // Order creates + { + RestApiResult r; + while (me_->callbacks.exe_report && me_->incoming_new_orders.pop(r)) { + if (!r.ok() || !r.response) { + WARN_FN( + "dispatch_incoming_fix_messages", + "Cannot generate exe report from BinanceCreateOrderResult. {}", + r.error); + continue; + } + bts::orderman::ExecutionReport &er = *me_->exe_report_pool.construct(); + if (!convert_execution_report( + *r.response, VENUE, me_->config.account, + &me_->jetfix_connection, er)) { + me_->exe_report_pool.destroy(&er); + WARN_FN( + "dispatch_incoming_fix_messages", + "Failed to generate exe report from CreateOrderResponse: {}", + nlohmann::json{*r.response}.dump()); + } + er.security = me_->sec_oracle.get_security(VENUE, r.response->symbol); + if (er.security == nullptr) { + WARN_FN( + "dispatch_incoming_fix_messages", + "Failed to resolve bts security from name '{}'", + r.response->symbol); + } + if (!IGNORE_CREATE_ORDER_RESPONSE) { + me_->callbacks.exe_report(er, {}); + } + } + } + // Order updates + { + user_data_streams::OrderUpdate u; + while (me_->callbacks.exe_report && me_->incoming_order_updates.pop(u)) { + bts::orderman::ExecutionReport &er = *me_->exe_report_pool.construct(); + if (!convert_execution_report( + u, VENUE, me_->config.account, &me_->jetfix_connection, er)) { + me_->exe_report_pool.destroy(&er); + WARN_FN( + "dispatch_incoming_fix_messages", + "Failed to generate exe report from OrderUpdate: {}", + nlohmann::json{u}.dump()); + } else { + er.security = me_->sec_oracle.get_security(VENUE, u.data.symbol); + me_->callbacks.exe_report(er, {}); + } + } + } + // Account updates + { + user_data_streams::AccountUpdate u; + auto &acct_upds = me_->account_updates_vec; + acct_upds.clear(); + while (me_->incoming_account_updates.pop(acct_upds.emplace_back())) { + } + acct_upds.pop_back(); + if (!acct_upds.empty()) { + convert_positions( + VENUE, me_->account, acct_upds, + [sec_oracle = &me_->sec_oracle]( + bts::api::Venue venue, const std::string &name) { + return sec_oracle->get_security(venue, name); + }, + me_->pos.total_exchange_positions); + if (me_->callbacks.exchange_position_state) { + me_->callbacks.exchange_position_state(me_->pos); + } + } + } +} + +// Callbacks +bts::orderman::OnExeReport &ExecutionGateway::on_exe_report() { + return me_->callbacks.exe_report; +} +bts::orderman::OnGwStatusChange &ExecutionGateway::on_gw_status_change() { + return me_->callbacks.gw_status_change; +} +bts::orderman::OnCancelReject &ExecutionGateway::on_cancel_reject() { + return me_->callbacks.cancel_reject; +} +bts::orderman::OnExchangePositionState & +ExecutionGateway::on_exchange_position_state() { + return me_->callbacks.exchange_position_state; +} +bts::orderman::OnExchangeOpenOrdersState & +ExecutionGateway::on_exchange_open_orders() { + return me_->callbacks.exchange_open_orders; +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.h b/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.h new file mode 100644 index 000000000..bfd4c8ca4 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway.h @@ -0,0 +1,43 @@ +#pragma once + +#include "binance_execution/usds_futures/execution_gateway_config.h" +#include "lib/md/SecurityOracle.h" +#include "lib/orderman/gateways/IExecutionGateway.h" + +#include + +namespace binance_execution::usds_futures { + +class ExecutionGateway : public bts::orderman::IExecutionGateway { + public: + explicit ExecutionGateway( + bts::md::SecurityOracle sec_oracle, + ExecutionGatewayConfig session_cfg, + std::string session_name); + ~ExecutionGateway() override; + + void start() override; + void dispatch_incoming_fix_messages() override; + void on_securities( + const bts::mercury::Update &) + override; + void on_admin_data( + const bts::mercury::Update &) override; + void send_fix(const bts::jetfix::OutFIXPtr &, bts::trace::CorID) override; + void send_msgs( + std::vector const &, + bts::trace::CorID) override; + + bts::orderman::OnExeReport &on_exe_report() override; + bts::orderman::OnGwStatusChange &on_gw_status_change() override; + bts::orderman::OnCancelReject &on_cancel_reject() override; + bts::orderman::OnExchangePositionState & + on_exchange_position_state() override; + bts::orderman::OnExchangeOpenOrdersState &on_exchange_open_orders() override; + + private: + struct PImpl; + std::unique_ptr me_; +}; + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway_config.h b/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway_config.h new file mode 100644 index 000000000..a4600f789 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/execution_gateway_config.h @@ -0,0 +1,37 @@ +#pragma once + +#include +#include +#include + +namespace binance_execution::usds_futures { + +struct ExecutionGatewayConfig { + std::string api_key; + std::string secret_key; + std::string account; + std::string rest_endpoint; + std::string ws_endpoint; + std::string ws_stream_endpoint; + + struct Subscription { + std::string symbol; + std::string pair; + std::string contract_type; + std::string base_asset; + std::string quote_asset; + }; + + std::vector subscriptions; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + ExecutionGatewayConfig, + api_key, + secret_key, + account, + rest_endpoint, + ws_endpoint, + ws_stream_endpoint); + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/all_orders_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/all_orders_request.h new file mode 100644 index 000000000..50c27f4ac --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/all_orders_request.h @@ -0,0 +1,109 @@ +#pragma once + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/All-Orders + */ +struct AllOrdersRequest { + std::string symbol; + std::int64_t orderId; + std::int64_t startTime; + std::int64_t endTime; + int limit; + std::int64_t recvWindow; + std::int64_t timestamp; +}; + +void to_json(nlohmann::json &j, const AllOrdersRequest &req); +void from_json(const nlohmann::json &j, AllOrdersRequest &req); + +void to_query_params(std::string &qps, const AllOrdersRequest &req); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const AllOrdersRequest &req) { + j["timestamp"] = req.timestamp; + if (!req.symbol.empty()) { + j["symbol"] = req.symbol; + } + if (req.orderId) { + j["orderId"] = req.orderId; + } + if (req.startTime) { + j["startTime"] = req.startTime; + } + if (req.endTime) { + j["endTime"] = req.endTime; + } + if (req.limit) { + j["limit"] = req.limit; + } + if (req.recvWindow) { + j["recvWindow"] = req.recvWindow; + } +} + +inline void from_json(const nlohmann::json &j, AllOrdersRequest &req) { + j.at("timestamp").get_to(req.timestamp); + auto it = j.find("symbol"); + if (it != j.end()) { + it->get_to(req.symbol); + } + it = j.find("orderId"); + if (it != j.end()) { + it->get_to(req.orderId); + } + it = j.find("startTime"); + if (it != j.end()) { + it->get_to(req.startTime); + } + it = j.find("endTime"); + if (it != j.end()) { + it->get_to(req.endTime); + } + it = j.find("limit"); + if (it != j.end()) { + it->get_to(req.limit); + } + it = j.find("recvWindow"); + if (it != j.end()) { + it->get_to(req.recvWindow); + } +} + +inline void to_query_params(std::string &qps, const AllOrdersRequest &req) { + qps.append("timestamp="); + qps.append(std::to_string(req.timestamp)); + if (!req.symbol.empty()) { + qps.append("&symbol="); + qps.append(req.symbol); + } + if (req.orderId) { + qps.append("&orderId="); + qps.append(std::to_string(req.orderId)); + } + if (req.startTime) { + qps.append("&startTime="); + qps.append(std::to_string(req.startTime)); + } + if (req.endTime) { + qps.append("&endTime="); + qps.append(std::to_string(req.endTime)); + } + if (req.limit) { + qps.append("&limit="); + qps.append(std::to_string(req.limit)); + } + if (req.recvWindow) { + qps.append("&recvWindow="); + qps.append(std::to_string(req.recvWindow)); + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_request.h new file mode 100644 index 000000000..54619362e --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_request.h @@ -0,0 +1,66 @@ +#pragma once + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Cancel-Order + */ +struct CancelOrderRequest { + std::int64_t orderId = 0; + std::string origClientOrderId; + std::string symbol; + std::int64_t timestamp = 0; +}; + +void to_json(nlohmann::json &j, const CancelOrderRequest &req); +void from_json(const nlohmann::json &j, CancelOrderRequest &req); + +void to_query_params(std::string &qps, const CancelOrderRequest &req); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const CancelOrderRequest &req) { + j["symbol"] = req.symbol; + if (req.orderId != 0) { + j["orderId"] = req.orderId; + } + if (!req.origClientOrderId.empty()) { + j["origClientOrderId"] = req.origClientOrderId; + } + j["timestamp"] = req.timestamp; +} + +inline void from_json(const nlohmann::json &j, CancelOrderRequest &req) { + j.at("symbol").get_to(req.symbol); + auto it = j.find("orderId"); + if (it != j.end()) { + it->get_to(req.orderId); + } + it = j.find("origClientOrderId"); + if (it != j.end()) { + it->get_to(req.origClientOrderId); + } + j.at("timestamp").get_to(req.timestamp); +} + +inline void to_query_params(std::string &qps, const CancelOrderRequest &req) { + qps.append("symbol="); + qps.append(req.symbol); + if (req.orderId != 0) { + qps.append("&orderId="); + qps.append(std::to_string(req.orderId)); + } + if (!req.origClientOrderId.empty()) { + qps.append("&origClientOrderId="); + qps.append(req.origClientOrderId); + } + qps.append("×tamp="); + qps.append(std::to_string(req.timestamp)); +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_response.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_response.h new file mode 100644 index 000000000..7846ed032 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/cancel_order_response.h @@ -0,0 +1,112 @@ +#pragma once + +#include "binance_execution/enums/order_status.h" +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/position_side.h" +#include "binance_execution/enums/price_match_mode.h" +#include "binance_execution/enums/self_trade_prevention_mode.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" +#include "binance_execution/enums/working_type.h" +#include "lib/io/JsonReader.h" + +#include +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Cancel-Order + */ +struct CancelOrderResponse { + std::string clientOrderId; + double cumQuote; + double executedQty; + std::int64_t orderId; + double origQty; + OrderType origType; + double price; + bool reduceOnly; + Side side; + PositionSide positionSide; + OrderStatus status; + double stopPrice; + bool closePosition; + std::string symbol; + TimeInForce timeInForce; + OrderType type; + double activatePrice; + double priceRate; + std::int64_t updateTime; + WorkingType workingType; + bool priceProtect; + PriceMatchMode priceMatch; + SelfTradePreventionMode selfTradePreventionMode; + std::int64_t goodTillDate; +}; + +void to_json(nlohmann::json &j, const CancelOrderResponse &res); +void from_json(const nlohmann::json &j, CancelOrderResponse &res); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const CancelOrderResponse &res) { + bts::io::JsonReader jr{&j}; + j["clientOrderId"] = res.clientOrderId; + j["cumQuote"] = res.cumQuote; + j["executedQty"] = res.executedQty; + j["orderId"] = res.orderId; + j["origQty"] = res.origQty; + j["origType"] = res.origType; + j["price"] = res.price; + j["reduceOnly"] = res.reduceOnly; + j["side"] = res.side; + j["positionSide"] = res.positionSide; + j["status"] = res.status; + j["stopPrice"] = res.stopPrice; + j["closePosition"] = res.closePosition; + j["symbol"] = res.symbol; + j["timeInForce"] = res.timeInForce; + j["type"] = res.type; + j["activatePrice"] = res.activatePrice; + j["priceRate"] = res.priceRate; + j["updateTime"] = res.updateTime; + j["workingType"] = res.workingType; + j["priceProtect"] = res.priceProtect; + j["priceMatch"] = res.priceMatch; + j["selfTradePreventionMode"] = res.selfTradePreventionMode; + j["goodTillDate"] = res.goodTillDate; +} + +inline void from_json(const nlohmann::json &j, CancelOrderResponse &res) { + bts::io::JsonReader jr{&j}; + j.at("clientOrderId").get_to(res.clientOrderId); + jr.read("cumQuote", res.cumQuote); + jr.read("executedQty", res.executedQty); + j.at("orderId").get_to(res.orderId); + jr.read("origQty", res.origQty); + j.at("origType").get_to(res.origType); + jr.read("price", res.price); + j.at("reduceOnly").get_to(res.reduceOnly); + j.at("side").get_to(res.side); + j.at("positionSide").get_to(res.positionSide); + j.at("status").get_to(res.status); + jr.read("stopPrice", res.stopPrice); + j.at("closePosition").get_to(res.closePosition); + j.at("symbol").get_to(res.symbol); + j.at("timeInForce").get_to(res.timeInForce); + j.at("type").get_to(res.type); + jr.read("activatePrice", res.activatePrice); + jr.read("priceRate", res.priceRate); + j.at("updateTime").get_to(res.updateTime); + j.at("workingType").get_to(res.workingType); + j.at("priceProtect").get_to(res.priceProtect); + j.at("priceMatch").get_to(res.priceMatch); + j.at("selfTradePreventionMode").get_to(res.selfTradePreventionMode); + j.at("goodTillDate").get_to(res.goodTillDate); +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_request.h new file mode 100644 index 000000000..4d34dde1a --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_request.h @@ -0,0 +1,120 @@ +#pragma once + +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" +#include "binance_execution/price.h" +#include "binance_execution/quantity.h" + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api + */ +struct CreateOrderRequest { + std::string symbol; + Side side = Side::NONE; + OrderType type = OrderType::NONE; + std::int64_t timestamp = 0; + std::string newClientOrderId; + double price = std::numeric_limits::quiet_NaN(); + double quantity = 0; + TimeInForce timeInForce = TimeInForce::NONE; + std::int64_t recvWindow = 0; +}; + +void to_json(nlohmann::json &j, const CreateOrderRequest &req); +void from_json(const nlohmann::json &j, CreateOrderRequest &req); + +void to_query_params(std::string &query_params, const CreateOrderRequest &req); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const CreateOrderRequest &req) { + j["symbol"] = req.symbol; + j["side"] = req.side; + j["type"] = req.type; + j["timestamp"] = req.timestamp; + if (!req.newClientOrderId.empty()) { + j["newClientOrderId"] = req.newClientOrderId; + } + if (!std::isnan(req.price)) { + std::string price_str; + price_to_string(req.price, price_str); + j["price"] = price_str; + } + if (req.quantity > 0) { + std::string qty_str; + quantity_to_string(req.quantity, qty_str); + j["quantity"] = qty_str; + } + if (req.timeInForce != TimeInForce::NONE) { + j["timeInForce"] = req.timeInForce; + } + if (req.recvWindow > 0) { + j["recvWindow"] = std::to_string(req.recvWindow); + } +} + +inline void from_json(const nlohmann::json &j, CreateOrderRequest &req) { + j.at("symbol").get_to(req.symbol); + j.at("side").get_to(req.side); + j.at("type").get_to(req.type); + j.at("timestamp").get_to(req.timestamp); + j.at("newClientOrderId").get_to(req.newClientOrderId); + auto it = j.find("price"); + if (it != j.end()) { + it->get_to(req.price); + } + it = j.find("quantity"); + if (it != j.end()) { + it->get_to(req.quantity); + } + it = j.find("timeInForce"); + if (it != j.end()) { + it->get_to(req.timeInForce); + } + it = j.find("recvWindow"); + if (it != j.end()) { + it->get_to(req.recvWindow); + } +} + +inline void to_query_params(std::string &qps, const CreateOrderRequest &req) { + qps.append("symbol="); + qps.append(req.symbol); + qps.append("&side="); + qps.append(req.side.name()); + qps.append("&type="); + qps.append(req.type.name()); + qps.append("×tamp="); + qps.append(std::to_string(req.timestamp)); + if (!req.newClientOrderId.empty()) { + qps.append("&newClientOrderId="); + qps.append(req.newClientOrderId); + } + // Format price & qty with 4 decimal places (should be sufficient the contracts we support) + if (!std::isnan(req.price)) { + qps.append("&price="); + price_to_string(req.price, qps); + } + if (req.quantity > 0) { + qps.append("&quantity="); + quantity_to_string(req.quantity, qps); + } + if (req.timeInForce != TimeInForce::NONE) { + qps.append("&timeInForce="); + qps.append(req.timeInForce.name()); + } + if (req.recvWindow > 0) { + qps.append("&recvWindow="); + qps.append(std::to_string(req.recvWindow)); + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_response.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_response.h new file mode 100644 index 000000000..fdc85fba5 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/create_order_response.h @@ -0,0 +1,113 @@ +#pragma once + +#include "binance_execution/enums/order_status.h" +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/position_side.h" +#include "binance_execution/enums/price_match_mode.h" +#include "binance_execution/enums/self_trade_prevention_mode.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" +#include "binance_execution/enums/working_type.h" +#include "lib/io/JsonReader.h" + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api + */ +struct CreateOrderResponse { + std::string clientOrderId; + double cumQty; + double cumQuote; + double executedQty; + std::int64_t orderId; + double avgPrice; + double origQty; + double price; + bool reduceOnly; + Side side; + PositionSide positionSide; + OrderStatus status; + double stopPrice; + bool closePosition; + std::string symbol; + TimeInForce timeInForce; + OrderType type; + OrderType origType; + double activatePrice; + double priceRate; + std::int64_t updateTime; + WorkingType workingType; + bool priceProtect; + PriceMatchMode priceMatch; + SelfTradePreventionMode selfTradePreventionMode; + std::int64_t goodTillDate; +}; + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const CreateOrderResponse &res) { + j["clientOrderId"] = res.clientOrderId; + j["cumQty"] = res.cumQty; + j["cumQuote"] = res.cumQuote; + j["executedQty"] = res.executedQty; + j["orderId"] = res.orderId; + j["avgPrice"] = res.avgPrice; + j["origQty"] = res.origQty; + j["price"] = res.price; + j["reduceOnly"] = res.reduceOnly; + j["side"] = res.side; + j["positionSide"] = res.positionSide; + j["status"] = res.status; + j["stopPrice"] = res.stopPrice; + j["closePosition"] = res.closePosition; + j["symbol"] = res.symbol; + j["timeInForce"] = res.timeInForce; + j["type"] = res.type; + j["origType"] = res.origType; + j["activatePrice"] = res.activatePrice; + j["priceRate"] = res.priceRate; + j["updateTime"] = res.updateTime; + j["workingType"] = res.workingType; + j["priceProtect"] = res.priceProtect; + j["priceMatch"] = res.priceMatch; + j["selfTradePreventionMode"] = res.selfTradePreventionMode; + j["goodTillDate"] = res.goodTillDate; +} + +inline void from_json(const nlohmann::json &j, CreateOrderResponse &res) { + bts::io::JsonReader jr{&j}; + j.at("clientOrderId").get_to(res.clientOrderId); + jr.read("cumQty", res.cumQty); + jr.read("cumQuote", res.cumQuote); + jr.read("executedQty", res.executedQty); + j.at("orderId").get_to(res.orderId); + jr.read("avgPrice", res.avgPrice); + jr.read("origQty", res.origQty); + jr.read("price", res.price); + j.at("reduceOnly").get_to(res.reduceOnly); + j.at("side").get_to(res.side); + j.at("positionSide").get_to(res.positionSide); + j.at("status").get_to(res.status); + jr.read("stopPrice", res.stopPrice); + j.at("closePosition").get_to(res.closePosition); + j.at("symbol").get_to(res.symbol); + j.at("timeInForce").get_to(res.timeInForce); + j.at("type").get_to(res.type); + j.at("origType").get_to(res.origType); + jr.read("activatePrice", res.activatePrice); + jr.read("priceRate", res.priceRate); + j.at("updateTime").get_to(res.updateTime); + j.at("workingType").get_to(res.workingType); + j.at("priceProtect").get_to(res.priceProtect); + j.at("priceMatch").get_to(res.priceMatch); + j.at("selfTradePreventionMode").get_to(res.selfTradePreventionMode); + j.at("goodTillDate").get_to(res.goodTillDate); +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_request.h new file mode 100644 index 000000000..7d2d50769 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_request.h @@ -0,0 +1,15 @@ +#pragma once + +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams + */ +struct ListenKeyRequest {}; + +inline void to_query_params( + std::string & /*qps*/, const ListenKeyRequest & /*req*/) {} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_response.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_response.h new file mode 100644 index 000000000..9ff34b6fb --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/listen_key_response.h @@ -0,0 +1,17 @@ +#pragma once + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams + */ +struct ListenKeyResponse { + std::string listenKey; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(ListenKeyResponse, listenKey); + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_request.h new file mode 100644 index 000000000..8b92aa257 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_request.h @@ -0,0 +1,107 @@ +#pragma once + +#include "binance_execution/enums/price_match_mode.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/price.h" +#include "binance_execution/quantity.h" + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Modify-Order + */ +struct ModifyOrderRequest { + std::int64_t orderId = 0; // *optional + std::string origClientOrderId; // *optional + std::string symbol; // mandatory + Side side = Side::NONE; // mandatory + double quantity = 0; // mandatory + double price = std::numeric_limits::quiet_NaN(); // mandatory + PriceMatchMode priceMatch = PriceMatchMode::NONE; // optional + std::int64_t recvWindow = 0; // optional + std::int64_t timestamp = 0; // mandatory + // * Either orderId or origClientOrderId must be specified +}; + +void to_json(nlohmann::json &j, const ModifyOrderRequest &req); +void from_json(const nlohmann::json &j, ModifyOrderRequest &req); + +void to_query_params(std::string &query_params, const ModifyOrderRequest &req); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const ModifyOrderRequest &req) { + if (req.orderId != 0) { + j["orderId"] = req.orderId; + } + if (!req.origClientOrderId.empty()) { + j["origClientOrderId"] = req.origClientOrderId; + } + j["symbol"] = req.symbol; + j["side"] = req.side; + j["quantity"] = req.quantity; + j["price"] = req.price; + if (req.priceMatch != PriceMatchMode::NONE) { + j["priceMatch"] = req.price; + } + if (req.recvWindow > 0) { + j["recvWindow"] = req.recvWindow; + } + j["timestamp"] = req.timestamp; +} + +inline void from_json(const nlohmann::json &j, ModifyOrderRequest &req) { + auto it = j.find("orderId"); + if (it != j.end()) { + it->get_to(req.orderId); + } + it = j.find("origClientOrderId"); + if (it != j.end()) { + it->get_to(req.origClientOrderId); + } + j.at("symbol").get_to(req.symbol); + j.at("side").get_to(req.side); + j.at("quantity").get_to(req.quantity); + j.at("price").get_to(req.price); + it = j.find("priceMatch"); + if (it != j.end()) { + it->get_to(req.priceMatch); + } + it = j.find("recvWindow"); + if (it != j.end()) { + it->get_to(req.recvWindow); + } + j.at("timestamp").get_to(req.timestamp); +} + +inline void to_query_params(std::string &qps, const ModifyOrderRequest &req) { + qps.append("symbol="); + qps.append(req.symbol); + qps.append("&side="); + qps.append(req.side.name()); + qps.append("&quantity="); + quantity_to_string(req.quantity, qps); + qps.append("&price="); + price_to_string(req.price, qps); + qps.append("×tamp="); + qps.append(std::to_string(req.timestamp)); + if (!req.origClientOrderId.empty()) { + qps.append("&origClientOrderId="); + qps.append(req.origClientOrderId); + } + if (req.orderId != 0) { + qps.append("&orderId="); + qps.append(std::to_string(req.orderId)); + } + if (req.recvWindow > 0) { + qps.append("&orderId="); + qps.append(std::to_string(req.orderId)); + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_response.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_response.h new file mode 100644 index 000000000..e4645b81c --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/modify_order_response.h @@ -0,0 +1,114 @@ +#pragma once + +#include "binance_execution/enums/order_status.h" +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/position_side.h" +#include "binance_execution/enums/price_match_mode.h" +#include "binance_execution/enums/self_trade_prevention_mode.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" +#include "binance_execution/enums/working_type.h" +#include "lib/io/JsonReader.h" + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Modify-Order + */ +struct ModifyOrderResponse { + std::int64_t orderId; + std::string symbol; + std::string pair; + OrderStatus status; + std::string clientOrderId; + double price; + double avgPrice; + double origQty; + double executedQty; + double cumQty; + double cumBase; + TimeInForce timeInForce; + OrderType type; + bool reduceOnly; + bool closePosition; + Side side; + PositionSide positionSide; + double stopPrice; + WorkingType workingType; + bool priceProtect; + OrderType origType; + PriceMatchMode priceMatch; + SelfTradePreventionMode selfTradePreventionMode; + std::int64_t goodTillDate; + std::int64_t updateTime; +}; + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const ModifyOrderResponse &res) { + j["orderId"] = res.orderId; + j["symbol"] = res.symbol; + // omit pair if empty + if (!res.pair.empty()) { + j["pair"] = res.pair; + } + j["status"] = res.status; + j["clientOrderId"] = res.clientOrderId; + j["price"] = res.price; + j["avgPrice"] = res.avgPrice; + j["origQty"] = res.origQty; + j["executedQty"] = res.executedQty; + j["cumQty"] = res.cumQty; + j["cumBase"] = res.cumBase; + j["timeInForce"] = res.timeInForce; + j["type"] = res.type; + j["reduceOnly"] = res.reduceOnly; + j["closePosition"] = res.closePosition; + j["side"] = res.side; + j["positionSide"] = res.positionSide; + j["stopPrice"] = res.stopPrice; + j["workingType"] = res.workingType; + j["priceProtect"] = res.priceProtect; + j["origType"] = res.origType; + j["priceMatch"] = res.priceMatch; + j["selfTradePreventionMode"] = res.selfTradePreventionMode; + j["goodTillDate"] = res.goodTillDate; + j["updateTime"] = res.updateTime; +} + +inline void from_json(const nlohmann::json &j, ModifyOrderResponse &res) { + bts::io::JsonReader jr{&j}; + j.at("orderId").get_to(res.orderId); + j.at("symbol").get_to(res.symbol); + // pair might be omitted + jr.read("pair", res.pair); + j.at("status").get_to(res.status); + j.at("clientOrderId").get_to(res.clientOrderId); + jr.read("price", res.price); + jr.read("avgPrice", res.avgPrice); + jr.read("origQty", res.origQty); + jr.read("executedQty", res.executedQty); + jr.read("cumQty", res.cumQty); + jr.read("cumBase", res.cumBase); + j.at("timeInForce").get_to(res.timeInForce); + j.at("type").get_to(res.type); + j.at("reduceOnly").get_to(res.reduceOnly); + j.at("closePosition").get_to(res.closePosition); + j.at("side").get_to(res.side); + j.at("positionSide").get_to(res.positionSide); + jr.read("stopPrice", res.stopPrice); + j.at("workingType").get_to(res.workingType); + j.at("priceProtect").get_to(res.priceProtect); + j.at("origType").get_to(res.origType); + j.at("priceMatch").get_to(res.priceMatch); + j.at("selfTradePreventionMode").get_to(res.selfTradePreventionMode); + j.at("goodTillDate").get_to(res.goodTillDate); + j.at("updateTime").get_to(res.updateTime); +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/open_orders_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/open_orders_request.h new file mode 100644 index 000000000..be0e453dd --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/open_orders_request.h @@ -0,0 +1,121 @@ +#pragma once + +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/trade/rest-api/Current-All-Open-Orders + */ +struct OpenOrdersRequest { + std::string symbol; + std::string pair; + std::int64_t orderId; + std::int64_t startTime; + std::int64_t endTime; + int limit; + std::int64_t recvWindow; + std::int64_t timestamp; +}; + +void to_json(nlohmann::json &j, const OpenOrdersRequest &req); +void from_json(const nlohmann::json &j, OpenOrdersRequest &req); + +void to_query_params(std::string &qps, const OpenOrdersRequest &req); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const OpenOrdersRequest &req) { + j["timestamp"] = req.timestamp; + if (!req.symbol.empty()) { + j["symbol"] = req.symbol; + } + if (!req.pair.empty()) { + j["pair"] = req.pair; + } + if (req.orderId) { + j["orderId"] = req.orderId; + } + if (req.startTime) { + j["startTime"] = req.startTime; + } + if (req.endTime) { + j["endTime"] = req.endTime; + } + if (req.limit) { + j["limit"] = req.limit; + } + if (req.recvWindow) { + j["recvWindow"] = req.recvWindow; + } +} + +inline void from_json(const nlohmann::json &j, OpenOrdersRequest &req) { + j.at("timestamp").get_to(req.timestamp); + auto it = j.find("symbol"); + if (it != j.end()) { + it->get_to(req.symbol); + } + it = j.find("pair"); + if (it != j.end()) { + it->get_to(req.pair); + } + it = j.find("orderId"); + if (it != j.end()) { + it->get_to(req.orderId); + } + it = j.find("startTime"); + if (it != j.end()) { + it->get_to(req.startTime); + } + it = j.find("endTime"); + if (it != j.end()) { + it->get_to(req.endTime); + } + it = j.find("limit"); + if (it != j.end()) { + it->get_to(req.limit); + } + it = j.find("recvWindow"); + if (it != j.end()) { + it->get_to(req.recvWindow); + } +} + +inline void to_query_params(std::string &qps, const OpenOrdersRequest &req) { + qps.append("timestamp="); + qps.append(std::to_string(req.timestamp)); + if (!req.symbol.empty()) { + qps.append("&symbol="); + qps.append(req.symbol); + } + if (!req.pair.empty()) { + qps.append("&pair="); + qps.append(req.pair); + } + if (req.orderId) { + qps.append("&orderId="); + qps.append(std::to_string(req.orderId)); + } + if (req.startTime) { + qps.append("&startTime="); + qps.append(std::to_string(req.startTime)); + } + if (req.endTime) { + qps.append("&endTime="); + qps.append(std::to_string(req.endTime)); + } + if (req.limit) { + qps.append("&limit="); + qps.append(std::to_string(req.limit)); + } + if (req.recvWindow) { + qps.append("&recvWindow="); + qps.append(std::to_string(req.recvWindow)); + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/order_record.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/order_record.h new file mode 100644 index 000000000..ac859d658 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/order_record.h @@ -0,0 +1,104 @@ +#pragma once + +#include "binance_execution/enums/order_status.h" +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/position_side.h" +#include "binance_execution/enums/price_match_mode.h" +#include "binance_execution/enums/self_trade_prevention_mode.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" +#include "binance_execution/enums/working_type.h" + +#include +#include + +namespace binance_execution::usds_futures { + +struct OrderRecord { + double avgPrice; + std::string clientOrderId; + double cumQuote; + double executedQty; + std::uint32_t orderId; + double origQty; + OrderType origType; + double price; + bool reduceOnly; + Side side; + PositionSide positionSide; + OrderStatus status; + double stopPrice; + bool closePosition; + std::string symbol; + std::int64_t time; + TimeInForce timeInForce; + OrderType type; + double activatePrice; + double priceRate; + std::int64_t updateTime; + WorkingType workingType; + bool priceProtect; + PriceMatchMode priceMatch; + SelfTradePreventionMode selfTradePreventionMode; + std::int64_t goodTillDate; +}; + +inline void to_json(nlohmann::json &j, const OrderRecord &r) { + j["avgPrice"] = r.avgPrice; + j["clientOrderId"] = r.clientOrderId; + j["cumQuote"] = r.cumQuote; + j["executedQty"] = r.executedQty; + j["orderId"] = r.orderId; + j["origQty"] = r.origQty; + j["origType"] = r.origType; + j["price"] = r.price; + j["reduceOnly"] = r.reduceOnly; + j["side"] = r.side; + j["positionSide"] = r.positionSide; + j["status"] = r.status; + j["stopPrice"] = r.stopPrice; + j["closePosition"] = r.closePosition; + j["symbol"] = r.symbol; + j["time"] = r.time; + j["timeInForce"] = r.timeInForce; + j["type"] = r.type; + j["activatePrice"] = r.activatePrice; + j["priceRate"] = r.priceRate; + j["updateTime"] = r.updateTime; + j["workingType"] = r.workingType; + j["priceProtect"] = r.priceProtect; + j["priceMatch"] = r.priceMatch; + j["selfTradePreventionMode"] = r.selfTradePreventionMode; + j["goodTillDate"] = r.goodTillDate; +} + +inline void from_json(const nlohmann::json &j, OrderRecord &r) { + j.at("avgPrice").get_to(r.avgPrice); + j.at("clientOrderId").get_to(r.clientOrderId); + j.at("cumQuote").get_to(r.cumQuote); + j.at("executedQty").get_to(r.executedQty); + j.at("orderId").get_to(r.orderId); + j.at("origQty").get_to(r.origQty); + j.at("origType").get_to(r.origType); + j.at("price").get_to(r.price); + j.at("reduceOnly").get_to(r.reduceOnly); + j.at("side").get_to(r.side); + j.at("positionSide").get_to(r.positionSide); + j.at("status").get_to(r.status); + j.at("stopPrice").get_to(r.stopPrice); + j.at("closePosition").get_to(r.closePosition); + j.at("symbol").get_to(r.symbol); + j.at("time").get_to(r.time); + j.at("timeInForce").get_to(r.timeInForce); + j.at("type").get_to(r.type); + j.at("activatePrice").get_to(r.activatePrice); + j.at("priceRate").get_to(r.priceRate); + j.at("updateTime").get_to(r.updateTime); + j.at("workingType").get_to(r.workingType); + j.at("priceProtect").get_to(r.priceProtect); + j.at("priceMatch").get_to(r.priceMatch); + j.at("selfTradePreventionMode").get_to(r.selfTradePreventionMode); + j.at("goodTillDate").get_to(r.goodTillDate); +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/position_info.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/position_info.h new file mode 100644 index 000000000..053e4ad75 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/position_info.h @@ -0,0 +1,92 @@ +#pragma once + +#include "binance_execution/enums/position_side.h" +#include "lib/io/JsonReader.h" + +#include +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams/Event-Balance-and-Position-Update + */ +struct PositionInfo { + std::string symbol; + PositionSide positionSide; + double positionAmt; + double entryPrice; + double breakEvenPrice; + double markPrice; + double unRealizedProfit; + double liquidationPrice; + double isolatedMargin; + double notional; + std::string marginAsset; + double isolatedWallet; + double initialMargin; + double maintMargin; + double positionInitialMargin; + double openOrderInitialMargin; + std::uint32_t adl; + double bidNotional; + double askNotional; + std::int64_t updateTime; +}; + +void to_json(nlohmann::json &j, const PositionInfo &p); +void from_json(const nlohmann::json &j, PositionInfo &p); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const PositionInfo &p) { + j["symbol"] = p.symbol; + j["positionSide"] = p.positionSide; + j["positionAmt"] = p.positionAmt; + j["entryPrice"] = p.entryPrice; + j["breakEvenPrice"] = p.breakEvenPrice; + j["markPrice"] = p.markPrice; + j["unRealizedProfit"] = p.unRealizedProfit; + j["liquidationPrice"] = p.liquidationPrice; + j["isolatedMargin"] = p.isolatedMargin; + j["notional"] = p.notional; + j["marginAsset"] = p.marginAsset; + j["isolatedWallet"] = p.isolatedWallet; + j["initialMargin"] = p.initialMargin; + j["maintMargin"] = p.maintMargin; + j["positionInitialMargin"] = p.positionInitialMargin; + j["openOrderInitialMargin"] = p.openOrderInitialMargin; + j["adl"] = p.adl; + j["bidNotional"] = p.bidNotional; + j["askNotional"] = p.askNotional; + j["updateTime"] = p.updateTime; +} + +inline void from_json(const nlohmann::json &j, PositionInfo &p) { + j.at("symbol").get_to(p.symbol); + j.at("positionSide").get_to(p.positionSide); + bts::io::JsonReader jr{&j}; + jr.read("positionAmt", p.positionAmt); + jr.read("entryPrice", p.entryPrice); + jr.read("breakEvenPrice", p.breakEvenPrice); + jr.read("markPrice", p.markPrice); + jr.read("unRealizedProfit", p.unRealizedProfit); + jr.read("liquidationPrice", p.liquidationPrice); + jr.read("isolatedMargin", p.isolatedMargin); + jr.read("notional", p.notional); + j.at("marginAsset").get_to(p.marginAsset); + jr.read("isolatedWallet", p.isolatedWallet); + jr.read("initialMargin", p.initialMargin); + jr.read("maintMargin", p.maintMargin); + jr.read("positionInitialMargin", p.positionInitialMargin); + jr.read("openOrderInitialMargin", p.openOrderInitialMargin); + j.at("adl").get_to(p.adl); + jr.read("bidNotional", p.bidNotional); + jr.read("askNotional", p.askNotional); + j.at("updateTime").get_to(p.updateTime); +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/messages/position_info_request.h b/src/lib_binance_execution/binance_execution/usds_futures/messages/position_info_request.h new file mode 100644 index 000000000..633d75093 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/messages/position_info_request.h @@ -0,0 +1,62 @@ +#pragma once + +#include +#include +#include + +namespace binance_execution::usds_futures { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams/Event-Balance-and-Position-Update + */ +struct PositionInfoRequest { + std::string symbol; + std::int64_t recvWindow; + std::int64_t timestamp; +}; + +void to_json(nlohmann::json &j, const PositionInfoRequest &req); +void from_json(const nlohmann::json &j, PositionInfoRequest &req); + +void to_query_params(std::string &qps, const PositionInfoRequest &req); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const PositionInfoRequest &req) { + j["timestamp"] = req.timestamp; + if (!req.symbol.empty()) { + j["symbol"] = req.symbol; + } + if (req.recvWindow) { + j["recvWindow"] = req.recvWindow; + } +} + +inline void from_json(const nlohmann::json &j, PositionInfoRequest &req) { + j.at("timestamp").get_to(req.timestamp); + auto it = j.find("symbol"); + if (it != j.end()) { + it->get_to(req.symbol); + } + it = j.find("recvWindow"); + if (it != j.end()) { + it->get_to(req.recvWindow); + } +} + +inline void to_query_params(std::string &qps, const PositionInfoRequest &req) { + qps.append("timestamp="); + qps.append(std::to_string(req.timestamp)); + if (!req.symbol.empty()) { + qps.append("&symbol="); + qps.append(req.symbol); + } + if (req.recvWindow) { + qps.append("&recvWindow="); + qps.append(std::to_string(req.recvWindow)); + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.cpp b/src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.cpp new file mode 100644 index 000000000..84ffd5b9f --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.cpp @@ -0,0 +1,109 @@ +#include "rest_api_client.h" +#include "lib/io/http/http_client.h" +#include "lib/io/http/http_response.h" +#include "lib/utils/crypto/hmac.h" + +namespace binance_execution::usds_futures { + +using bts::http::HttpClient; +using bts::http::HttpResponse; +using bts::system::crypto::hmac_digest_hex; +using std::string; + +#define _LOG_FN(level, fn, ...) \ + LOG(OrderMan, level, "RestApiClient::" fn ". " __VA_ARGS__) +#define DIAG_FN(fn, ...) _LOG_FN(bts::Diag, fn, __VA_ARGS__) +#define INFO_FN(fn, ...) _LOG_FN(bts::Info, fn, __VA_ARGS__) +#define WARN_FN(fn, ...) _LOG_FN(bts::Warn, fn, __VA_ARGS__) +#define ERROR_FN(fn, ...) _LOG_FN(bts::Error, fn, __VA_ARGS__) + +template +static void shrink_string(std::string &str) { + if (str.size() > MAX_SIZE) { + str.resize(DEFAULT_SIZE); + str.shrink_to_fit(); + } +} + +template +static void shrink_vec(std::vector &vec) { + if (vec.size() > MAX_SIZE) { + vec.resize(DEFAULT_SIZE); + vec.shrink_to_fit(); + } +} + +bool RestApiClient::sign_query_params_(std::string &qp) { + std::string signature; + if (!hmac_digest_hex(secret_key_, qp, signature)) { + LOG(OrderMan, bts::Error, "Failed to sign request. {}", qp); + return false; + } + static constexpr const std::string SIGNATURE_LABEL = "&signature="; + qp.reserve(qp.size() + SIGNATURE_LABEL.size() + signature.size()); + qp.append(SIGNATURE_LABEL); + qp.append(signature); + return true; +} + +template +void RestApiClient::request_( + const RequestT &req, + const std::string &path, + bts::io::http::HttpMethod method, + const std::string &body, + RestApiResult &res) { + // Use thread_local vars to reduce memory allocations. Shrink strings + // to reduce memory footprint from previous requests. + thread_local bts::http::HttpRequest http_req; + shrink_string<4096, 128>(http_req.body); + http_req.reset(); + // Prepare request + http_req.url = url_; + http_req.url.append(path); + http_req.body = body; + http_req.method = method; + http_req.headers["X-MBX-APIKEY"] = api_key_; + thread_local std::string qps; + shrink_string<256, 16>(qps); + qps.clear(); + to_query_params(qps, req); + if (!qps.empty()) { + sign_query_params_(qps); + http_req.url.append("?"); + http_req.url.append(qps); + } + // Send it + thread_local HttpResponse http_res; + shrink_string<4096, 128>(http_res.body); + http_res.reset(); + HttpClient::send(http_req, &http_res); + if (!http_res.ok()) { + ERROR_FN("{} {}", "res: {}", method, path, http_res); + res.error = std::move(http_res.errors); + return; + } + // Parse response + INFO_FN("{} {}", "res: {}", method, path, http_res); + try { + nlohmann::json::parse(http_res.body).get_to(res.response.emplace()); + } catch (const std::exception &ex) { + ERROR_FN("{} {}", "ex: {}", method, path, string{ex.what()}); + bts_assert_msgf(false, "Failed to parse {} response", path); + } +} + +#define REQUEST_DEF(ResponseT, RequestT) \ + template void RestApiClient::request_( \ + const RequestT &req, const std::string &path, \ + bts::io::http::HttpMethod method, const std::string &body, \ + RestApiResult &res) + +REQUEST_DEF(CreateOrderResponse, CreateOrderRequest); +REQUEST_DEF(ModifyOrderResponse, ModifyOrderRequest); +REQUEST_DEF(CancelOrderResponse, CancelOrderRequest); +REQUEST_DEF(std::vector, AllOrdersRequest); +REQUEST_DEF(std::vector, PositionInfoRequest); +REQUEST_DEF(ListenKeyResponse, ListenKeyRequest); + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.h b/src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.h new file mode 100644 index 000000000..bc4db6b85 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/rest_api_client.h @@ -0,0 +1,136 @@ +#pragma once + +#include "binance_execution/usds_futures/messages/all_orders_request.h" +#include "binance_execution/usds_futures/messages/cancel_order_request.h" +#include "binance_execution/usds_futures/messages/cancel_order_response.h" +#include "binance_execution/usds_futures/messages/create_order_request.h" +#include "binance_execution/usds_futures/messages/create_order_response.h" +#include "binance_execution/usds_futures/messages/listen_key_request.h" +#include "binance_execution/usds_futures/messages/listen_key_response.h" +#include "binance_execution/usds_futures/messages/modify_order_request.h" +#include "binance_execution/usds_futures/messages/modify_order_response.h" +#include "binance_execution/usds_futures/messages/order_record.h" +#include "binance_execution/usds_futures/messages/position_info.h" +#include "binance_execution/usds_futures/messages/position_info_request.h" +#include "binance_execution/usds_futures/rest_api_result.h" +#include "lib/io/http/HttpMethod.h" + +#include +#include +#include + +namespace binance_execution::usds_futures { + +class RestApiClient { + public: + explicit RestApiClient( + std::string url, std::string api_key, std::string secret_key); + + const RestApiResult &create_order( + const CreateOrderRequest &req); + const RestApiResult &modify_order( + const ModifyOrderRequest &req); + const RestApiResult &cancel_order( + const CancelOrderRequest &req); + const RestApiResult> &get_all_orders( + const AllOrdersRequest &req); + const RestApiResult> &get_position_info( + const PositionInfoRequest &req); + const RestApiResult &get_listen_key( + const ListenKeyRequest &req = {}); + const RestApiResult &refresh_listen_key( + const ListenKeyRequest &req = {}); + + private: + std::string url_; + std::string api_key_; + std::string secret_key_; + + template + void request_( + const RequestT &req, + const std::string &path, + bts::io::http::HttpMethod method, + const std::string &body, + RestApiResult &op_res); + + bool sign_query_params_(std::string &qp); +}; + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline RestApiClient::RestApiClient( + std::string url, std::string api_key, std::string secret_key) + : url_(std::move(url)), api_key_(std::move(api_key)), + secret_key_(std::move(secret_key)) {} + +inline const RestApiResult &RestApiClient::create_order( + const CreateOrderRequest &req) { + static constexpr const std::string path{"/fapi/v1/order"}; + thread_local RestApiResult res; + res.reset(); + request_( + req, path, bts::io::http::HttpMethod::POST, "", res); + return res; +} + +inline const RestApiResult &RestApiClient::modify_order( + const ModifyOrderRequest &req) { + static const std::string path{"/fapi/v1/order"}; + thread_local RestApiResult res; + res.reset(); + request_( + req, path, bts::io::http::HttpMethod::PUT, "", res); + return res; +} + +inline const RestApiResult &RestApiClient::cancel_order( + const CancelOrderRequest &req) { + static const std::string path{"/fapi/v1/order"}; + thread_local RestApiResult res; + res.reset(); + request_( + req, path, bts::io::http::HttpMethod::DELETE, "", res); + return res; +} + +inline const RestApiResult> & +RestApiClient::get_all_orders(const AllOrdersRequest &req) { + static const std::string path{"/fapi/v1/allOrders"}; + thread_local RestApiResult> res; + res.reset(); + request_>( + req, path, bts::io::http::HttpMethod::GET, "", res); + return res; +} + +inline const RestApiResult> & +RestApiClient::get_position_info(const PositionInfoRequest &req) { + static const std::string path{"/fapi/v3/positionRisk"}; + thread_local RestApiResult> res; + res.reset(); + request_(req, path, bts::io::http::HttpMethod::GET, "", res); + return res; +} + +inline const RestApiResult &RestApiClient::get_listen_key( + const ListenKeyRequest &req) { + static const std::string path{"/fapi/v1/listenKey"}; + thread_local RestApiResult res; + res.reset(); + request_(req, path, bts::io::http::HttpMethod::POST, "", res); + return res; +} + +inline const RestApiResult & +RestApiClient::refresh_listen_key(const ListenKeyRequest &req) { + static const std::string path{"/fapi/v1/listenKey"}; + thread_local RestApiResult res; + res.reset(); + request_(req, path, bts::io::http::HttpMethod::PUT, "", res); + return res; +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/rest_api_result.h b/src/lib_binance_execution/binance_execution/usds_futures/rest_api_result.h new file mode 100644 index 000000000..a66eb287c --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/rest_api_result.h @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +namespace binance_execution::usds_futures { + +template +struct RestApiResult { + std::string error; + std::optional response; + + RestApiResult() = default; + + static RestApiResult from_error(const std::string &error) { + return RestApiResult{error}; + } + + static RestApiResult from_success(ResponseT response) { + return RestApiResult{std::move(response)}; + } + + constexpr bool ok() const { return error.empty(); } + + void reset() { + error.clear(); + response.reset(); + } + + private: + explicit RestApiResult(ResponseT response) : response(std::move(response)) {} + + explicit RestApiResult(std::string error) : error(std::move(error)) {} +}; + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/type_converters.cpp b/src/lib_binance_execution/binance_execution/usds_futures/type_converters.cpp new file mode 100644 index 000000000..a5e9c3332 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/type_converters.cpp @@ -0,0 +1,147 @@ +#include "type_converters.h" +#include "lib/api/services/AdminService.pb.h" +#include "lib/utils/checked_arithmetic.h" +#include "lib/utils/string_utils.h" + +namespace binance_execution::usds_futures { + +using bts::system::string_utils::copy_to_array; +using bts::system::string_utils::parse_uint; +using std::string; +using std::vector; + +bool convert_execution_report( + const user_data_streams::OrderUpdate &u, + bts::api::Venue venue, + const std::string &account, + const bts::config::JetFIX_Connection *jetfix_cfg, + bts::orderman::ExecutionReport &er) { + copy_to_array<12>(account, er.account_name.value()); + er.exchange = venue; + er.transact_time = bts::orderman::ExchangeTimeStamp64{ + convert_time_stamp(u.transaction_time).nanos()}; + if (!parse_uint(u.data.client_order_id, er.order_key.value())) { + return false; + } + bts_assert(bts::system::math::checked_ltoul( + u.data.order_id, + er.exchange_order_id.emplace() + .value())); + er.security = nullptr; + er.leg_security = nullptr; + er.side = + u.data.side == Side::BUY ? bts::api::SIDE_BUY : bts::api::SIDE_SELL; + er.time_in_force = convert_time_in_force(u.data.time_in_force); + er.order_type = convert_order_type(u.data.order_type); + er.exec_type = convert_exec_type(u.data.execution_type, u.data.order_status); + er.order_status = convert_order_status(u.data.order_status); + er.manual_order_indicator = bts::api::orderman::MANUAL_ORDER_INDICATOR_NO; + er.price.value() = u.data.orig_price; + er.quantity = u.data.orig_quantity; + er.filled_quantity = u.data.total_filled_qty; + er.last_shares = u.data.last_filled_qty; + // er.max_show = u.data.; + er.last_price.value() = u.data.last_filled_price; + er.avg_price.value() = u.data.avg_price; + er.stop_price.value() = u.data.stop_price; + copy_to_array<40>( + std::to_string(u.data.trade_id), er.exchange_fill_id.value()); + // er.msg = u.reject_reason; + er.cfg = jetfix_cfg; + // Irrelevant fields + er.ice_cl_ord_id = 0; + er.ice_company_id = 0; + er.memo = ""; + return true; +} + +bool convert_execution_report( + const CreateOrderResponse &res, + bts::api::Venue venue, + const std::string &account, + const bts::config::JetFIX_Connection *jetfix_cfg, + bts::orderman::ExecutionReport &er) { + copy_to_array<12>(account, er.account_name.value()); + er.exchange = venue; + er.transact_time = bts::orderman::ExchangeTimeStamp64{ + convert_time_stamp(res.updateTime).nanos()}; + if (!parse_uint(res.clientOrderId, er.order_key.value())) { + return false; + } + bts_assert(bts::system::math::checked_ltoul( + res.orderId, + er.exchange_order_id.emplace() + .value())); + er.security = nullptr; + er.leg_security = nullptr; + er.side = res.side == Side::BUY ? bts::api::SIDE_BUY : bts::api::SIDE_SELL; + er.time_in_force = convert_time_in_force(res.timeInForce); + er.order_type = convert_order_type(res.type); + er.exec_type = bts::api::orderman::EXEC_TYPE_NEW; + er.order_status = convert_order_status(res.status); + er.manual_order_indicator = bts::api::orderman::MANUAL_ORDER_INDICATOR_NO; + er.price.value() = res.price; + er.quantity = res.origQty; + er.filled_quantity = res.executedQty; + er.last_shares = res.executedQty; + er.max_show = 0; + er.last_price.value() = res.avgPrice; + er.avg_price.value() = res.avgPrice; + er.stop_price.value() = res.stopPrice; + er.msg = ""; + er.cfg = jetfix_cfg; + // Irrelevant fields + er.ice_cl_ord_id = 0; + er.ice_company_id = 0; + er.memo = ""; + return true; +} + +struct ExchPosCmp { + bool operator()( + const string &ticker, + const bts::orderman::ExchangePosition::UnitPosition &u) { + return ticker < u.exchange_sec_desc; + } + + bool operator()( + const bts::orderman::ExchangePosition::UnitPosition &u, + const string &ticker) { + return u.exchange_sec_desc < ticker; + } +}; + +void convert_positions( + bts::api::Venue venue, + const bts::api::admin::BTSAccount &account, + const vector &acct_upds, + std::function get_security, + vector &dest) { + ExchPosCmp exch_pos_cmp; + for (const auto &acct_upd : acct_upds) { + for (const auto &pos : acct_upd.data.positions) { + bts_assert(pos.position_amount >= 0); + auto it = std::lower_bound( + dest.begin(), dest.end(), pos.symbol, exch_pos_cmp); + if (it == dest.end() || it->exchange_sec_desc != pos.symbol) { + const auto *sec = get_security(venue, pos.symbol); + if (sec == nullptr) { + continue; + } + bts::orderman::ExchangePosition::UnitPosition new_pos; + new_pos.exchange_sec_desc = pos.symbol; + new_pos.security = sec; + new_pos.account_id = account.id(); + new_pos.account_name = account.name(); + it = dest.insert(it, new_pos); + } + it->position = pos.position_side == PositionSide::SHORT + ? -pos.position_amount + : pos.position_amount; + it->avg_filled_price.value() = pos.break_even_price; + } + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/type_converters.h b/src/lib_binance_execution/binance_execution/usds_futures/type_converters.h new file mode 100644 index 000000000..e92d6938a --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/type_converters.h @@ -0,0 +1,263 @@ +#pragma once + +#include "binance_execution/enums/execution_type.h" +#include "binance_execution/enums/order_status.h" +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" +#include "binance_execution/usds_futures/messages/create_order_response.h" +#include "binance_execution/usds_futures/user_data_streams/account_update.h" +#include "binance_execution/usds_futures/user_data_streams/order_update.h" +#include "lib/api/services/OrderService.pb.h" +#include "lib/config/protos/jetfix.pb.h" +#include "lib/domain/Side.h" +#include "lib/orderman/orderman_utils/ExchangePosition.h" +#include "lib/orderman/orderman_utils/ExecutionReport.h" +#include "lib/utils/bts_assert.h" + +namespace bts::api::admin { +class BTSAccount; +} + +namespace binance_execution::usds_futures { + +bts::api::orderman::NativeOrderType convert_order_type(OrderType tif); +OrderType convert_order_type(bts::api::orderman::NativeOrderType tif); + +bts::api::orderman::NativeOrderStatus convert_order_status(OrderStatus status); + +bts::api::orderman::TimeInForce convert_time_in_force(TimeInForce tif); +TimeInForce convert_time_in_force(bts::api::orderman::TimeInForce tif); + +bts::core::TimeStamp convert_time_stamp(std::int64_t ts); +std::int64_t convert_time_stamp(bts::core::TimeStamp ts); + +std::int64_t convert_time_span(bts::core::TimeSpan ts); +bts::core::TimeSpan convert_time_span(std::int64_t ts); + +bts::domain::Side convert_side(Side side); +Side convert_side(bts::domain::Side side); +Side convert_side(bts::api::Side side); + +bts::api::orderman::ExecType convert_exec_type( + ExecutionType exec_type, OrderStatus order_status); +bts::api::orderman::ExecType convert_exec_type( + ExecutionType exec_type, bool is_filled); +ExecutionType convert_exec_type(bts::api::orderman::ExecType exec_type); + +bool convert_execution_report( + const user_data_streams::OrderUpdate &u, + bts::api::Venue venue, + const std::string &account, + const bts::config::JetFIX_Connection *jetfix_cfg, + bts::orderman::ExecutionReport &er); +bool convert_execution_report( + const CreateOrderResponse &res, + bts::api::Venue venue, + const std::string &account, + const bts::config::JetFIX_Connection *jetfix_cfg, + bts::orderman::ExecutionReport &er); + +void convert_positions( + bts::api::Venue venue, + const bts::api::admin::BTSAccount &account, + const std::vector &acct_upds, + std::function get_security, + std::vector &dest); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline bts::api::orderman::NativeOrderType convert_order_type(OrderType tif) { + switch (tif.value) { + case OrderType::LIMIT: + return bts::api::orderman::NATIVE_ORDER_TYPE_LIMIT; + case OrderType::MARKET: + return bts::api::orderman::NATIVE_ORDER_TYPE_MARKET; + case OrderType::NONE: + return bts::api::orderman::NATIVE_ORDER_TYPE_UNDEFINED; + default: + bts_assert_msg(false, "Unknown BinanceOrderType"); + return bts::api::orderman::NATIVE_ORDER_TYPE_UNDEFINED; + } +} + +inline bts::api::orderman::NativeOrderStatus convert_order_status( + OrderStatus status) { + switch (status.value) { + case OrderStatus::NEW: + return bts::api::orderman::NATIVE_ORDER_STATUS_NEW; + case OrderStatus::PENDING_NEW: + return bts::api::orderman::NATIVE_ORDER_STATUS_PENDING_NEW; + case OrderStatus::PARTIALLY_FILLED: + return bts::api::orderman::NATIVE_ORDER_STATUS_PARTIALLY_FILLED; + case OrderStatus::FILLED: + return bts::api::orderman::NATIVE_ORDER_STATUS_FILLED; + case OrderStatus::CANCELED: + return bts::api::orderman::NATIVE_ORDER_STATUS_CANCELED; + case OrderStatus::REJECTED: + return bts::api::orderman::NATIVE_ORDER_STATUS_REJECTED; + case OrderStatus::EXPIRED: + case OrderStatus::EXPIRED_IN_MATCH: + return bts::api::orderman::NATIVE_ORDER_STATUS_EXPIRED; + case OrderStatus::NONE: + return bts::api::orderman::NATIVE_ORDER_STATUS_UNDEFINED; + default: + bts_assert_msg(false, "Unknown BinanceOrderStatus"); + return bts::api::orderman::NATIVE_ORDER_STATUS_UNDEFINED; + } +} + +inline bts::core::TimeStamp convert_time_stamp(std::int64_t ts) { + return bts::core::TimeStamp::from_millis(ts); +} + +inline std::int64_t convert_time_stamp(bts::core::TimeStamp ts) { + return static_cast(ts.millis()); +} + +inline bts::core::TimeSpan convert_time_span(std::int64_t ts) { + return bts::core::TimeSpan::from_millis(ts); +} + +inline std::int64_t convert_time_span(bts::core::TimeSpan ts) { + return static_cast(ts.millis()); +} + +inline bts::domain::Side convert_side(Side side) { + switch (side.value) { + case Side::BUY: + return bts::domain::Side::Buy; + case Side::SELL: + return bts::domain::Side::Sell; + default: + bts_assert_msg( + false, "Failed to convert BinanceSide to bts::domain::Side"); + return bts::domain::Side::Buy; + } +} + +inline Side convert_side(bts::domain::Side side) { + switch (side.value) { + case bts::domain::Side::Buy: + return Side::BUY; + case bts::domain::Side::Sell: + return Side::SELL; + default: + bts_assert_msg( + false, "Failed to convert bts::domain::Side to BinanceSide"); + return Side::NONE; + } +} + +inline Side convert_side(bts::api::Side side) { + switch (side) { + case bts::api::SIDE_BUY: + return Side::BUY; + case bts::api::SIDE_SELL: + return Side::SELL; + default: + bts_assert_msg(false, "Failed to convert bts::api::Side to BinanceSide"); + return Side::NONE; + } +} + +inline bts::api::orderman::TimeInForce convert_time_in_force(TimeInForce tif) { + switch (tif.value) { + case TimeInForce::GTC: + return bts::api::orderman::TIME_IN_FORCE_GTC; + case TimeInForce::IOC: + case TimeInForce::FOK: + return bts::api::orderman::TIME_IN_FORCE_IOC; + case TimeInForce::NONE: + return bts::api::orderman::TIME_IN_FORCE_UNDEFINED; + default: + bts_assert_msg(false, "Unknown BinanceTimeInForce"); + return bts::api::orderman::TIME_IN_FORCE_UNDEFINED; + } +} + +inline bts::api::orderman::ExecType convert_exec_type( + ExecutionType exec_type, OrderStatus order_status) { + return convert_exec_type(exec_type, order_status == OrderStatus::FILLED); +} + +inline bts::api::orderman::ExecType convert_exec_type( + ExecutionType exec_type, bool is_filled) { + switch (exec_type.value) { + case ExecutionType::NEW: + return bts::api::orderman::EXEC_TYPE_NEW; + case ExecutionType::CANCELED: + return bts::api::orderman::EXEC_TYPE_CANCELED; + case ExecutionType::REPLACED: + return bts::api::orderman::EXEC_TYPE_REPLACED; + case ExecutionType::REJECTED: + case ExecutionType::TRADE_PREVENTION: + return bts::api::orderman::EXEC_TYPE_REJECTED; + case ExecutionType::TRADE: + return is_filled ? bts::api::orderman::EXEC_TYPE_FILL + : bts::api::orderman::EXEC_TYPE_PARTIAL_FILL; + case ExecutionType::EXPIRED: + return bts::api::orderman::EXEC_TYPE_EXPIRED; + case ExecutionType::NONE: + return bts::api::orderman::EXEC_TYPE_UNDEFINED; + default: + bts_assert_msg(false, "Unknown BinanceExecutionType"); + return bts::api::orderman::EXEC_TYPE_UNDEFINED; + } +} + +inline OrderType convert_order_type(bts::api::orderman::NativeOrderType tif) { + switch (tif) { + case bts::api::orderman::NATIVE_ORDER_TYPE_LIMIT: + return OrderType::LIMIT; + case bts::api::orderman::NATIVE_ORDER_TYPE_MARKET: + return OrderType::MARKET; + case bts::api::orderman::NATIVE_ORDER_TYPE_UNDEFINED: + return OrderType::NONE; + default: + bts_assert_msgf( + false, "NativeOrderType '{}' not implemented at Binance", + bts::api::orderman::NativeOrderType_Name(tif)); + return OrderType::NONE; + } +} + +inline TimeInForce convert_time_in_force(bts::api::orderman::TimeInForce tif) { + switch (tif) { + case bts::api::orderman::TIME_IN_FORCE_GTC: + case bts::api::orderman::TIME_IN_FORCE_DAY: + return TimeInForce::GTC; + case bts::api::orderman::TIME_IN_FORCE_IOC: + return TimeInForce::IOC; + case bts::api::orderman::TIME_IN_FORCE_UNDEFINED: + return TimeInForce::NONE; + default: + bts_assert_msg(false, "Unknown BinanceTimeInForce"); + return TimeInForce::NONE; + } +} + +inline ExecutionType convert_exec_type(bts::api::orderman::ExecType exec_type) { + switch (exec_type) { + case bts::api::orderman::EXEC_TYPE_NEW: + case bts::api::orderman::EXEC_TYPE_PENDING_NEW: + return ExecutionType::NEW; + case bts::api::orderman::EXEC_TYPE_FILL: + case bts::api::orderman::EXEC_TYPE_PARTIAL_FILL: + return ExecutionType::TRADE; + case bts::api::orderman::EXEC_TYPE_CANCELED: + return ExecutionType::CANCELED; + case bts::api::orderman::EXEC_TYPE_REJECTED: + return ExecutionType::REJECTED; + case bts::api::orderman::EXEC_TYPE_EXPIRED: + return ExecutionType::EXPIRED; + default: + bts_assert_msg(false, "Unknown BinanceExecutionType"); + return ExecutionType::NONE; + } +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/account_update.h b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/account_update.h new file mode 100644 index 000000000..67326017a --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/account_update.h @@ -0,0 +1,133 @@ +#pragma once + +#include "binance_execution/enums/event_reason_type.h" +#include "binance_execution/enums/position_side.h" +#include "lib/io/JsonReader.h" + +#include +#include + +namespace binance_execution::usds_futures::user_data_streams { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams/Event-Balance-and-Position-Update + */ +struct AccountUpdate { + struct Balance { + std::string asset; // json: a + double wallet_balance; // json: wb + double cross_wallet_balance; // json: cw + double balance_change; // json: bc + }; + + struct Position { + std::string symbol; // json: s + double position_amount; // json: pa + double entry_price; // json: ep + double break_even_price; // json: bep + double realized_pnl; // json: cr + double unrealized_pnl; // json: up + std::string margin_type; // json: mt + double isolated_wallet; // json: iw + PositionSide position_side; // json: ps + }; + + struct Data { + EventReasonType event_reason_type; // json: m + std::vector balances; // json: B + std::vector positions; // json: P + }; + + std::string event_type; // json: e + std::int64_t event_time; // json: E + std::int64_t transaction_time; // json: T + Data data; // json: a +}; + +void to_json(nlohmann::json &j, const AccountUpdate::Balance &b); +void from_json(const nlohmann::json &j, AccountUpdate::Balance &b); + +void to_json(nlohmann::json &j, const AccountUpdate::Position &b); +void from_json(const nlohmann::json &j, AccountUpdate::Position &p); + +void to_json(nlohmann::json &j, const AccountUpdate::Data &d); +void from_json(const nlohmann::json &j, AccountUpdate::Data &d); + +void to_json(nlohmann::json &j, const AccountUpdate &u); +void from_json(const nlohmann::json &j, AccountUpdate &u); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const AccountUpdate::Balance &b) { + j["a"] = b.asset; + j["wb"] = b.wallet_balance; + j["cw"] = b.cross_wallet_balance; + j["bc"] = b.balance_change; +} + +inline void from_json(const nlohmann::json &j, AccountUpdate::Balance &b) { + bts::io::JsonReader jr{&j}; + j.at("a").get_to(b.asset); + jr.read("wb", b.wallet_balance); + jr.read("cw", b.cross_wallet_balance); + jr.read("bc", b.balance_change); +} + +inline void to_json(nlohmann::json &j, const AccountUpdate::Position &b) { + j["s"] = b.symbol; + j["pa"] = b.position_amount; + j["ep"] = b.entry_price; + j["bep"] = b.break_even_price; + j["cr"] = b.realized_pnl; + j["up"] = b.unrealized_pnl; + j["mt"] = b.margin_type; + j["iw"] = b.isolated_wallet; + j["ps"] = b.position_side; +} + +inline void from_json(const nlohmann::json &j, AccountUpdate::Position &p) { + bts::io::JsonReader jr{&j}; + j.at("s").get_to(p.symbol); + jr.read("pa", p.position_amount); + jr.read("ep", p.entry_price); + jr.read("bep", p.break_even_price); + jr.read("cr", p.realized_pnl); + jr.read("up", p.unrealized_pnl); + j.at("mt").get_to(p.margin_type); + jr.read("iw", p.isolated_wallet); + j.at("ps").get_to(p.position_side); +} + +inline void to_json(nlohmann::json &j, const AccountUpdate::Data &d) { + j["m"] = d.event_reason_type; + j["B"] = d.balances; + j["P"] = d.positions; +} + +inline void from_json(const nlohmann::json &j, AccountUpdate::Data &d) { + j.at("m").get_to(d.event_reason_type); + j.at("B").get_to(d.balances); + j.at("P").get_to(d.positions); +} + +inline void to_json(nlohmann::json &j, const AccountUpdate &u) { + j["e"] = u.event_type; + j["E"] = u.event_time; + j["T"] = u.transaction_time; + j["a"] = u.data; +} + +inline void from_json(const nlohmann::json &j, AccountUpdate &u) { + j.at("e").get_to(u.event_type); + j.at("E").get_to(u.event_time); + j.at("T").get_to(u.transaction_time); + j.at("a").get_to(u.data); +}; + +} // namespace binance_execution::usds_futures::user_data_streams diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.cpp b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.cpp new file mode 100644 index 000000000..93845c722 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.cpp @@ -0,0 +1,81 @@ +#include "listen_key_requestor.h" +#include "binance_execution/usds_futures/rest_api_client.h" +#include "lib/core/TimeStamp.h" + +#include +#include + +namespace binance_execution::usds_futures { + +using bts::core::Delegate; +using bts::core::TimeStamp; +using std::optional; +using std::string; +using std::thread; + +struct ListenKeyRequestor::PImpl { + RestApiClient rest_api_client; + string listen_key; + TimeStamp listen_key_timestamp; + optional listen_key_thread; + Delegate callback; + bool is_running = false; + + PImpl(RestApiClient rest_api_client) + : rest_api_client(std::move(rest_api_client)) {} + + ~PImpl() { stop(); } + + void start() { + bts_assert(!is_running); + is_running = true; + listen_key_thread.emplace([this]() { run(); }); + } + + void stop() { + is_running = false; + if (listen_key_thread) { + listen_key_thread->join(); + } + } + + void run() { + while (is_running) { + static const auto refresh_period = + bts::core::TimeSpan::from_seconds(60 * 30); + const auto now = bts::core::TimeStamp::now(); + if (listen_key.empty()) { + const auto &res = rest_api_client.get_listen_key(); + if (!res.ok()) { + continue; + } + bts_assert_msgf( + res.ok(), "Failed to get listen key. {}", res.error); + listen_key = res.response->listenKey; + bts_assert(!listen_key.empty()); + listen_key_timestamp = now; + callback(listen_key); + } + if ((now - listen_key_timestamp) > refresh_period) { + const auto &res = rest_api_client.refresh_listen_key(); + bts_assert_msgf( + res.ok(), "Failed to refresh listen key. {}", res.error); + listen_key_timestamp = now; + } + std::this_thread::sleep_for(std::chrono::seconds(2)); + } + } +}; + +ListenKeyRequestor::ListenKeyRequestor(RestApiClient rest_api_client) + : me_(std::make_unique(std::move(rest_api_client))) {} + +ListenKeyRequestor::~ListenKeyRequestor() = default; + +void ListenKeyRequestor::start() { me_->start(); } +void ListenKeyRequestor::stop() { me_->stop(); } +Delegate &ListenKeyRequestor::callback() { + return me_->callback; +} + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.h b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.h new file mode 100644 index 000000000..7a6740aae --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/listen_key_requestor.h @@ -0,0 +1,30 @@ +#pragma once + +#include "binance_execution/usds_futures/rest_api_client.h" +#include "lib/utils/Delegate.h" +#include + +namespace binance_execution::usds_futures { + +/** + * Requests the listen key for user data stream subscriptions, and periodically + * refreshes it to keep subscriptions alive. + * + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams + */ +class ListenKeyRequestor { + public: + explicit ListenKeyRequestor(RestApiClient rest_api_client); + ~ListenKeyRequestor(); + + void start(); + void stop(); + + bts::core::Delegate &callback(); + + private: + struct PImpl; + std::unique_ptr me_; +}; + +} // namespace binance_execution::usds_futures diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.cpp b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.cpp new file mode 100644 index 000000000..61f718b72 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.cpp @@ -0,0 +1,81 @@ +#include "order_update.h" +#include "lib/io/JsonReader.h" + +namespace binance_execution::usds_futures::user_data_streams { + +void to_json(nlohmann::json &j, const OrderUpdate::Data &d) { + j["s"] = d.symbol; + j["c"] = d.client_order_id; + j["S"] = d.side; + j["o"] = d.order_type; + j["f"] = d.time_in_force; + j["q"] = d.orig_quantity; + j["p"] = d.orig_price; + j["ap"] = d.avg_price; + j["sp"] = d.stop_price; + j["x"] = d.execution_type; + j["X"] = d.order_status; + j["i"] = d.order_id; + j["l"] = d.last_filled_qty; + j["z"] = d.total_filled_qty; + j["L"] = d.last_filled_price; + j["N"] = d.commission_asset; + j["n"] = d.commission; + j["T"] = d.trade_time; + j["t"] = d.trade_id; + j["b"] = d.bids_notional; + j["a"] = d.ask_notional; + j["m"] = d.is_maker_trade; + j["R"] = d.is_reduce_only; + j["wt"] = d.stop_price_working_type; + j["ot"] = d.orig_order_type; + j["ps"] = d.position_side; + j["cp"] = d.close_all; + j["AP"] = d.activation_price; + j["cr"] = d.callback_rate; + j["pP"] = d.is_price_protection_on; + j["rp"] = d.realized_trade_pnl; + j["V"] = d.stp_mode; + j["pm"] = d.price_match_mode; + j["gtd"] = d.good_till_time; +} + +void from_json(const nlohmann::json &j, OrderUpdate::Data &d) { + j.at("s").get_to(d.symbol); + j.at("c").get_to(d.client_order_id); + j.at("S").get_to(d.side); + j.at("o").get_to(d.order_type); + j.at("f").get_to(d.time_in_force); + bts::io::JsonReader jr{&j}; + jr.read("q", d.orig_quantity); + jr.read("p", d.orig_price); + jr.read("ap", d.avg_price); + jr.read("sp", d.stop_price); + j.at("x").get_to(d.execution_type); + j.at("X").get_to(d.order_status); + jr.read("i", d.order_id); + jr.read("l", d.last_filled_qty); + jr.read("z", d.total_filled_qty); + jr.read("L", d.last_filled_price); + j.at("N").get_to(d.commission_asset); + jr.read("n", d.commission); + j.at("T").get_to(d.trade_time); + jr.read("t", d.trade_id); + jr.read("b", d.bids_notional); + jr.read("a", d.ask_notional); + j.at("m").get_to(d.is_maker_trade); + j.at("R").get_to(d.is_reduce_only); + j.at("wt").get_to(d.stop_price_working_type); + j.at("ot").get_to(d.orig_order_type); + j.at("ps").get_to(d.position_side); + j.at("cp").get_to(d.close_all); + jr.read("AP", d.activation_price); + jr.read("cr", d.callback_rate); + j.at("pP").get_to(d.is_price_protection_on); + jr.read("rp", d.realized_trade_pnl); + j.at("V").get_to(d.stp_mode); + j.at("pm").get_to(d.price_match_mode); + j.at("gtd").get_to(d.good_till_time); +} + +} // namespace binance_execution::usds_futures::user_data_streams diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.h b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.h new file mode 100644 index 000000000..71f91b9b5 --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/order_update.h @@ -0,0 +1,89 @@ +#pragma once + +#include "binance_execution/enums/execution_type.h" +#include "binance_execution/enums/order_status.h" +#include "binance_execution/enums/order_type.h" +#include "binance_execution/enums/position_side.h" +#include "binance_execution/enums/price_match_mode.h" +#include "binance_execution/enums/side.h" +#include "binance_execution/enums/time_in_force.h" + +#include +#include +#include + +namespace binance_execution::usds_futures::user_data_streams { + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams/Event-Order-Update + */ +struct OrderUpdate { + std::string event_type; // json: e + std::int64_t event_time; // json: E + std::int64_t transaction_time; // json: T + + struct Data { + std::string symbol; // json: s + std::string client_order_id; // json: c + Side side; // json: S + OrderType order_type; // json: o + TimeInForce time_in_force; // json: f + double orig_quantity; // json: q + double orig_price; // json: p + double avg_price; // json: ap + double stop_price; // json: sp + ExecutionType execution_type; // json: x + OrderStatus order_status; // json: X + std::int64_t order_id; // json: i + double last_filled_qty; // json: l + double total_filled_qty; // json: z + double last_filled_price; // json: L + std::string commission_asset; // json: N + double commission; // json: n + std::int64_t trade_time; // json: T + std::uint32_t trade_id; // json: t + double bids_notional; // json: b + double ask_notional; // json: a + bool is_maker_trade; // json: m + bool is_reduce_only; // json: R + std::string stop_price_working_type; // json: wt + OrderType orig_order_type; // json: ot + PositionSide position_side; // json: ps + bool close_all; // json: cp + double activation_price; // json: AP + double callback_rate; // json: cr + bool is_price_protection_on; // json: pP + double realized_trade_pnl; // json: rp + std::string stp_mode; // json: V + PriceMatchMode price_match_mode; // json: pm + std::int64_t good_till_time; // json: gtd + }; + + Data data; // json: o +}; + +void to_json(nlohmann::json &j, const OrderUpdate::Data &d); +void from_json(const nlohmann::json &j, OrderUpdate::Data &d); + +void to_json(nlohmann::json &j, const OrderUpdate &u); +void from_json(const nlohmann::json &j, OrderUpdate &u); + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json(nlohmann::json &j, const OrderUpdate &u) { + j["e"] = u.event_type; + j["E"] = u.event_time; + j["T"] = u.transaction_time; + j["o"] = u.data; +} + +inline void from_json(const nlohmann::json &j, OrderUpdate &u) { + j.at("e").get_to(u.event_type); + j.at("E").get_to(u.event_time); + j.at("T").get_to(u.transaction_time); + j.at("o").get_to(u.data); +} + +} // namespace binance_execution::usds_futures::user_data_streams diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.cpp b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.cpp new file mode 100644 index 000000000..087703fcc --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.cpp @@ -0,0 +1,163 @@ +#include "user_data_subscription.h" +#include "binance_execution/usds_futures/user_data_streams/account_update.h" +#include "binance_execution/usds_futures/user_data_streams/order_update.h" +#include "lib/core/TimeStamp.h" +#include "lib/io/websocket/websocket_client.h" +#include "lib/logging/logging.h" + +#include +#include +#include +#include + +namespace binance_execution::usds_futures::user_data_streams { + +#define _LOG_FN(level, fn, ...) \ + LOG(OrderMan, level, "UserDataSubscription::" fn ". " __VA_ARGS__) +#define DIAG_FN(fn, ...) _LOG_FN(bts::Diag, fn, __VA_ARGS__) +#define INFO_FN(fn, ...) _LOG_FN(bts::Info, fn, __VA_ARGS__) +#define WARN_FN(fn, ...) _LOG_FN(bts::Warn, fn, __VA_ARGS__) +#define ERROR_FN(fn, ...) _LOG_FN(bts::Error, fn, __VA_ARGS__) + +using bts::core::Delegate; +using bts::core::TimeSpan; +using bts::core::TimeStamp; +using bts::websocket::WebsocketClient; +using bts::websocket::WebsocketClientConfig; +using nlohmann::json; +using std::exception; +using std::lock_guard; +using std::mutex; +using std::optional; +using std::string; +using std::thread; + +struct UserDataSubscription::PImpl { + explicit PImpl(string url) : url(std::move(url)) {} + ~PImpl() { stop(); } + + string url; + mutex instance_mx; + optional ws_client; + optional ws_run_thread; + optional ws_ping_thread; + + Delegate account_update_callback; + Delegate order_update_callback; + + void start() { + lock_guard lock{instance_mx}; + INFO_FN("start", "Subscribing to user data"); + bts_assert(!ws_client); + bts_assert(!ws_run_thread); + bts_assert(!ws_ping_thread); + LOG(OrderMan, bts::Info, "Creating websocket client. url: {}", url); + WebsocketClientConfig ws_stream_client_cfg; + ws_stream_client_cfg.url = url; + auto &ws_cli = ws_client.emplace(ws_stream_client_cfg); + ws_cli.message_handler().bind<&PImpl::on_message>(*this); + ws_cli.close_handler().bind<&PImpl::on_close>(*this); + INFO_FN("start", "Creating websocket client. url: {}", url); + ws_cli.connect({}, false); + ws_run_thread.emplace([&]() { + DIAG_FN("ws_run_thread", "thread starting. url: {}", url); + ws_cli.run(); + DIAG_FN("ws_run_thread", "thread exiting. url: {}", url); + }); + ws_ping_thread.emplace([&]() { + DIAG_FN("ws_ping_thread", "thread starting. url: {}", url); + auto last_ping_time = TimeStamp::now(); + static constexpr const auto ping_interval = TimeSpan::from_seconds(25); + std::this_thread::sleep_for( + std::chrono::milliseconds(ping_interval.millis())); + + while (ws_cli.is_connected()) { + const auto now = bts::core::TimeStamp::now(); + if ((now - last_ping_time) > ping_interval) { + DIAG_FN("ws_ping_thread", "Pinging websocket. url: {}", url); + ws_cli.ping(); + last_ping_time = now; + } + std::this_thread::sleep_for(std::chrono::seconds(2)); + } + DIAG_FN("ws_ping_thread", "thread exiting. url: {}", url); + }); + } + + void stop() { + lock_guard lock{instance_mx}; + if (ws_client) { + bts_assert(ws_run_thread); + bts_assert(ws_ping_thread); + ws_client->disconnect(); + ws_ping_thread->join(); + ws_run_thread->join(); + ws_client.reset(); + } + } + + void on_message(const string &msg_str) { + DIAG_FN("on_message", "{}", msg_str); + json msg; + try { + msg = json::parse(msg_str); + } catch (const exception &ex) { + LOG(OrderMan, bts::Error, "Failed to parse json. {}\n{}", + string{ex.what()}, msg_str); + return; + } + const auto event_type_it = msg.find("e"); + if (event_type_it != msg.end()) { + const auto event_type = event_type_it->get(); + if (event_type == "ACCOUNT_UPDATE") { + try { + account_update_callback( + msg.get()); + } catch (const std::exception &ex) { + ERROR_FN( + "on_message", "account_update callback threw: {}", + string{ex.what()}); + } + } else if (event_type == "ORDER_TRADE_UPDATE") { + try { + order_update_callback(msg.get()); + } catch (const std::exception &ex) { + ERROR_FN( + "on_message", "order_update callback threw: {}", + string{ex.what()}); + } + } else { + ERROR_FN( + "on_message", "Response has unexpected event type '{}'", + event_type); + } + return; + } + ERROR_FN("on_message", "Failed to process response json: {}", msg_str); + } + + void on_close(const std::error_code &ec) { + bts_assert_msgf( + false, "Websocket stream client disconnected. {}", ec.message()); + } +}; + +UserDataSubscription::UserDataSubscription(string url) + : me_(std::make_unique(std::move(url))) {} + +UserDataSubscription::~UserDataSubscription() = default; + +void UserDataSubscription::start() { me_->start(); } +void UserDataSubscription::stop() { me_->stop(); } + +Delegate & +UserDataSubscription::account_update_callback() { + return me_->account_update_callback; +} + +Delegate & +UserDataSubscription::order_update_callback() { + return me_->order_update_callback; +} + +} // namespace binance_execution::usds_futures::user_data_streams diff --git a/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.h b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.h new file mode 100644 index 000000000..1ff1f2a6a --- /dev/null +++ b/src/lib_binance_execution/binance_execution/usds_futures/user_data_streams/user_data_subscription.h @@ -0,0 +1,30 @@ +#pragma once + +#include "binance_execution/usds_futures/user_data_streams/account_update.h" +#include "binance_execution/usds_futures/user_data_streams/order_update.h" +#include "lib/utils/Delegate.h" + +#include + +namespace binance_execution::usds_futures::user_data_streams { + + +/** + * @a https://developers.binance.com/docs/derivatives/usds-margined-futures/user-data-streams + */ +class UserDataSubscription { + public: + explicit UserDataSubscription(std::string url); + ~UserDataSubscription(); + + void start(); + void stop(); + bts::core::Delegate &account_update_callback(); + bts::core::Delegate &order_update_callback(); + + private: + struct PImpl; + std::unique_ptr me_; +}; + +} // namespace binance_execution::usds_futures::user_data_streams diff --git a/src/server/sparkd/CMakeLists.txt b/src/server/sparkd/CMakeLists.txt index 0c26d8f3c..d40cc0e20 100644 --- a/src/server/sparkd/CMakeLists.txt +++ b/src/server/sparkd/CMakeLists.txt @@ -76,6 +76,7 @@ endif() # linking target_link_libraries(sparkd PUBLIC libspark + binance_execution databento::databento ${emumba-deribit-connector-library_LIBRARIES} ssl diff --git a/src/server/sparkd/cmds/Run.cpp b/src/server/sparkd/cmds/Run.cpp index da6befc3e..e5c785caf 100644 --- a/src/server/sparkd/cmds/Run.cpp +++ b/src/server/sparkd/cmds/Run.cpp @@ -1,4 +1,5 @@ #include "Run.h" +#include "binance_execution/execution_gateway_provider.h" #include "lib/api/public/ServiceContext.h" #include "lib/config/config.h" #include "lib/config/protos/ports.pb.h" @@ -14,6 +15,7 @@ #include "lib/metrics/metrics.h" #include "lib/metrics/system_metrics.h" #include "lib/orderman/OrderServiceServer.h" +#include "lib/orderman/gateways/execution_gateway_provider.h" #include "lib/orderman/gateways/sim/SimExecutionGatewayFactory.h" #include "lib/orderman/order_factory/DynamicOrderRegistry.h" #include "lib/orderman/orders/algo/algo_orders/ProRataAlgo.h" @@ -47,6 +49,36 @@ namespace bts::cmds { +using bts::api::ServiceContext; +using bts::md::MDClient; +using bts::md::TradeSummarySignalDispatcher; +using bts::metrics::MetricsContainer; +using bts::orderman::DynamicOrderRegistry; +using bts::orderman::ExecutionGatewayProvider; +using bts::orderman::IExecutionGatewayProvider; +using bts::orderman::OrderServiceServer; +using bts::trace::PerfLog; +using std::unique_ptr; +using std::vector; + +static OrderServiceServer create_order_service_server( + ServiceContext &sc, + MDClient &mdclient, + DynamicOrderRegistry &dyn_order_registry, + MetricsContainer &stats, + PerfLog &perf_log, + TradeSummarySignalDispatcher &tss_dispatcher) { + vector> gw_pros; + gw_pros.push_back(std::make_unique( + &perf_log, mdclient.oracle())); + gw_pros.push_back( + std::make_unique( + mdclient.oracle())); + return OrderServiceServer( + sc, mdclient, dyn_order_registry, std::move(gw_pros), stats, perf_log, + tss_dispatcher); +} + static void execute() { using namespace bts; LOG(Gen, Warn, @@ -56,8 +88,7 @@ static void execute() { auto qb_cfg = config::get().node(); auto &ports = config::get(); qb_cfg.set_my_port(ports.qbus_port()); - qbus::Quickbus quickbus( - qb_cfg, qbus::QuickbusThreadOptions::DEFERRED_START); + qbus::Quickbus quickbus(qb_cfg, qbus::QuickbusThreadOptions::DEFERRED_START); api::ServiceContext sc(&quickbus); trace::PerfLog perf_log; @@ -90,7 +121,7 @@ static void execute() { plugin::init_plugins(plugin_services); // finished initializing order plugins - orderman::OrderServiceServer order_service_server( + auto order_service_server = create_order_service_server( sc, mdclient, dyn_order_registry, stats, perf_log, tss_dispatcher); support::ErrorReportServer error_report_service(sc); admin::AdminServiceServer admin_service(sc);