#include "SimExecutionGateway.h" #include "lib/api/services/AdminService.pb.h" #include "lib/api/services/ApiUnitTestService.pb.h" #include "lib/api/services/OrderService.pb.h" #include "lib/core/TimeStamp.h" #include "lib/domain_model/Security.h" #include "lib/domain_model/Security.pb.h" #include "lib/domain_model/SecurityKey.h" #include "lib/domain_model/common.h" #include "lib/logging/logging.h" #include "lib/md/GeneralSecurityIndex.h" #include "lib/md/IntPrice.h" #include "lib/md/MDClient.h" #include "lib/md/MDProducer.h" #include "lib/md/PriceSize.h" #include "lib/md/Shm/MDStructure.h" #include "lib/orderman/OrderMsg.h" #include "lib/orderman/events/NewAdminDataEvent.h" #include "lib/orderman/events/NewSecuritiesEvent.h" #include "lib/orderman/gateways/IExecutionGateway.h" #include "lib/orderman/orderman_utils/Book.h" #include "lib/orderman/orderman_utils/ExecutionReport.h" #include "lib/orderman/orderman_utils/orderman_common.h" #include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" #include "lib/os/os.h" #include "lib/tracing/bts_trace.h" #include "lib/utils/Puid.h" #include "lib/utils/TimeStamp.h" #include "lib/utils/Uuid.h" #include "lib/utils/bts_assert.h" #include "lib/utils/bts_chrono.h" #include "lib/utils/helper_macros.h" #include "lib/utils/thread_manager.h" #include #include #include #include #include #include #include #include #include #include #include namespace bts::orderman { // book conversions /////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////// // Copies bid, asks received from market data to the book (they are diff // sized arrays). Also removes the 0 qtys void to_book( const std::array &bids, const std::array &asks, bts::orderman::Book &book) { auto copy_side = [](const std::array &from, BookSide &bk_to) { size_t to_idx = 0; for (const auto &l : from) { if (Quantity::create_new(l.size()).is_zero()) { continue; } bk_to[to_idx++] = l; if (to_idx >= bk_to.size()) break; } }; copy_side(bids, book.bid()); copy_side(asks, book.ask()); } // Opposite of the above void from_book( const bts::orderman::Book &book, std::array &bids, std::array &asks) { auto copy_side = [](const BookSide &bk_from, std::array &to) { for (size_t i = 0; i < std::min(to.size(), bk_from.size()); i++) { to[i] = bk_from[i]; } }; copy_side(book.bid(), bids); copy_side(book.ask(), asks); } bts::md::IntPrice convert_price(Price p) { return bts::md::IntPrice_from_double<7>(p.value()); } void log_ord_msg(std::string /*log_prefix*/, const OrderMsg & /*ord_msg*/) { // auto sleep_period = std::chrono::milliseconds(500); // std::this_thread::sleep_for(sleep_period); // LOG(OrderMan, Info, "{} {}", log_prefix, ord_msg); //std::this_thread::sleep_for(sleep_period); } void fill_execution_report(const SEGOrderState &seg_os, ExecutionReport &er); // This is the result of applying a new OrderMsg enum class ActionResult { NewOrder, OrderModification, NoOp }; // Every order send to sim is represented here. These are contained as a vector // in SEGSecurityData struct SEGOrderState { CreateOrderMsg crt_msg; bts::Quantity filled_qty = 0; bts::Price avg_filled_price = bts::Price(0); bts::Quantity last_filled_qty = 0; bts::Price last_filled_price = bts::Price(os::nan()); bts::api::orderman::NativeOrderStatus status = bts::api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_NEW; bts::core::TimeStamp last_touched = bts::core::TimeStamp::from_nanos(bts::core::TimeStamp::now_ns()); SEGOrderState(const CreateOrderMsg &crt_msg) : crt_msg(crt_msg) {} // immutable getters OrderKey ord_key() const { return crt_msg.key; } bts::SecurityKey sec_key() const { return bts::SecurityKey(crt_msg.security->id()); } bts::Price price() const { return crt_msg.price; } bts::Quantity qty() const { return crt_msg.quantity; } api::Side side() const { return crt_msg.side; } bts::Quantity working_qty() const { auto rv = qty() - filled_qty; rv.make_zero_if_negative(); return rv; } bool active() const { auto int_status = bts::orderman::get_external_status(status); bool terminal = bts::orderman::in_terminal_state(int_status); return !terminal; } // mutators //////////////////////////////////////////////////////////////// void apply_fill(Price lf_pr, Quantity lf_qty) { if (!active()) { LOG(OrderMan, Error, "SEGOrderState::apply_fill called on an inactive order"); } last_filled_price = lf_pr; last_filled_qty = lf_qty; avg_filled_price = Price( (avg_filled_price.value() * filled_qty.full_value() + lf_pr.value() * lf_qty.full_value()) / (filled_qty.full_value() + lf_qty.full_value())); filled_qty = Quantity::create_new(filled_qty.full_value() + lf_qty.full_value()); status = api::orderman::NATIVE_ORDER_STATUS_PARTIALLY_FILLED; if (working_qty().is_zero()) { status = api::orderman::NATIVE_ORDER_STATUS_FILLED; } } ActionResult apply_change(const CancelReplaceOrderMsg &cxl_repl_msg) { if (!active()) // already in final state, further changes will be rejected return ActionResult::NoOp; // if price changes or qty increases, time gets updated if (cxl_repl_msg.create_fields.quantity > qty() || !securities::is_same(price(), cxl_repl_msg.create_fields.price)) last_touched = bts::core::TimeStamp::from_nanos(bts::core::TimeStamp::now_ns()); crt_msg = cxl_repl_msg.create_fields; // if qty is reduced, it can result in a cancel if (working_qty().is_zero()) { status = api::orderman::NATIVE_ORDER_STATUS_CANCELED; } return ActionResult::OrderModification; } ActionResult apply_cxl(const CancelOrderMsg &) { if (!active()) return ActionResult::NoOp; status = api::orderman::NATIVE_ORDER_STATUS_CANCELED; return ActionResult::OrderModification; } void clear_after_transaction() { last_filled_qty = 0; last_filled_price = Price(os::nan()); } }; struct SEGTradeEntry { api::Side side; Price price; Quantity qty; }; // Represents a security and all its data (orders, book, and transient data) struct SEGSecurityData { bts::SecurityKey key = SecurityKey{0}; // book as sent by get_matched_book bts::orderman::Book real_book = {}; // after the orders have been integated into real_book bts::orderman::Book matched_book = {}; std::vector orders = {}; std::queue pending_actions = {}; // these are all the trades that our orders crossed against the real market. // they are recorded here and then later subtracted from the real book std::vector trades = {}; SEGOrderState *find_order(OrderKey key) { for (auto &seg_os : orders) { if (seg_os.ord_key() == key) { return &seg_os; } } return nullptr; } // actions are enqueued and taken care of at the end of the transaction void enqueue_action(const OrderMsg &ord_msg) { pending_actions.push(ord_msg); } // applies the action (ie new, cxl, mod) and returns the order alongside // the result of the action std::tuple apply_order_action( const OrderMsg &msg) { // create results in a new order entry, otherwise apply_change or // apply_cxl are called on an existing entry if (std::holds_alternative(msg)) { const CreateOrderMsg &cr_msg = std::get(msg); auto &it = orders.emplace_back(cr_msg); return {ActionResult::NewOrder, &it}; } else if (std::holds_alternative(msg)) { const CancelReplaceOrderMsg &cxlr_msg = std::get(msg); SEGOrderState *seg_os = find_order(cxlr_msg.create_fields.key); if(seg_os == nullptr){ LOG(OrderMan, Info, "SimExecutionGateway::apply_order_action tried updating unkown order"); return {ActionResult::NoOp, nullptr}; } auto action_result = seg_os->apply_change(cxlr_msg); return {action_result, seg_os}; } else if (std::holds_alternative(msg)) { const CancelOrderMsg &cxl_msg = std::get(msg); SEGOrderState *seg_os = find_order(cxl_msg.key); if(seg_os == nullptr){ LOG(OrderMan, Info, "SimExecutionGateway::apply_order_action tried canceling unkown order"); return {ActionResult::NoOp, nullptr}; } auto action_result = seg_os->apply_cxl(cxl_msg); return {action_result, seg_os}; } return {ActionResult::NoOp, nullptr}; } void clear_after_transaction() { bts_assert(pending_actions.empty()); for (auto &seg_os : orders) { seg_os.clear_after_transaction(); } } void remove_inactive_orders() { return; // orders.erase( // std::remove_if( // orders.begin(), orders.end(), // [](const auto &ord) { return !ord.active(); }), // orders.end()); } void record_trade(const SEGTradeEntry &seg_te) { trades.push_back(seg_te); } }; struct SimExecutionGateway::PImpl { PImpl(bts::api::Venue venue) : venue(venue) { LOG(OrderMan, Info, "SimExecutionGateway::PImpl constructor venue: {}", bts::api::Venue_Name(venue)); } // interface functions const bts::api::Venue venue; const bool perm_reduce_book_by_trades = true; OnExeReport on_exe_report; OnGwStatusChange on_gw_status_change; OnCancelReject on_cancel_reject; orderman::OnExchangePositionState on_exchange_position_state; orderman::OnExchangeOpenOrdersState on_exchange_open_orders; md::GeneralSecurityIndex *producer_map = nullptr; // send_msgs is sent on the order_man thread, its dequeued in the market data // thread, and execution reports are queued to buffered_exec_reps tbb::concurrent_queue buffered_order_ops; tbb::concurrent_queue buffered_exec_reps; std::unordered_map books = {}; tbb::concurrent_hash_map sec_map = {}; boost::object_pool exe_report_pool; size_t msg_seq_num = 0; std::set touched_secs; api::Security const *find_sec(uint32_t key) const { tbb::concurrent_hash_map::const_accessor accessor; if (!sec_map.find(accessor, key)) { return nullptr; } return accessor->second; } }; SimExecutionGateway::SimExecutionGateway(bts::api::Venue venue) : IExecutionGateway(), me(new PImpl(venue)) { LOG(OrderMan, Info, "SimExecutionGateway::SimExecutionGateway constructor venue: {} tid: {} " "tname: " "{}", bts::api::Venue_Name(venue), bts::os::get_thread_id(), bts::os::get_thread_name()); } SimExecutionGateway::~SimExecutionGateway() {} void SimExecutionGateway::start() { LOG(OrderMan, Info, "SimExecutionGateway::start venue: {} tid: {} tname: {}", bts::api::Venue_Name(me->venue), bts::os::get_thread_id(), bts::os::get_thread_name()); } // this is a periodic timer, to process the messages we got from the // exchange and send the resulting execution reports up by calling // on_exe_report void SimExecutionGateway::dispatch_incoming_fix_messages() { if (me->buffered_exec_reps.empty()) { return; } ExecutionReport *er; while (me->buffered_exec_reps.try_pop(er)) { trace::CorID cid = {}; LOG(OrderMan, Info, "ESimExecutionGateway::dispatch_incoming_fix_messages er: {} ", er->to_string()); me->on_exe_report(*er, cid); } } void SimExecutionGateway::on_securities( const mercury::Update &u) { LOG(OrderMan, Info, "SimExecutionGateway::on_securities venue: {} n_secs: {} tid: {} tname: " "{}", bts::api::Venue_Name(me->venue), u.events == nullptr ? 0 : u.events->size(), bts::os::get_thread_id(), bts::os::get_thread_name()); if (u.events == nullptr) return; for (const auto &s : *u.events) { me->sec_map.insert(std::make_pair(s.security->id(), s.security)); } } void SimExecutionGateway::on_admin_data( const mercury::Update &) { LOG(OrderMan, Info, "SimExecutionGateway::on_admin_data venue: {} tid: {} tname: {}", bts::api::Venue_Name(me->venue), bts::os::get_thread_id(), bts::os::get_thread_name()); } void SimExecutionGateway::send_fix(const jetfix::OutFIXPtr &p, trace::CorID) { LOG(OrderMan, Warn, "SimExecutionGateway::send_fix p sz: {}", p->fix.size()); // TODO //bts_assert(false); } int msg_type(const OrderMsg &msg) { // if (std::holds_alternative(msg)) { // return 1; // } else if (std::holds_alternative(msg)) { // return 2; // } else if (std::holds_alternative(msg)) { // return 3; // } return msg.index(); } // This is where the messages are received from the client. For sim, // we simply write the operation to a concurrent queue (buffered_order_ops) // and dequeue in the market data thread (when the market data source needs the matched_books) // (the resulting execution rerports are written to another conrrent queue) // which is then dequeued on dispatch_incoming_fix_messages) void SimExecutionGateway::send_msgs( std::vector const &msg_vec, trace::CorID) { // this is where it will be sent to the exchange (to simulate we'll just put // in the buffer and generate execution reports from it in the // dispatch_incoming_fix_messages call LOG(OrderMan, Info, "SimExecutionGateway::send_msgs tid: {} tname: {} count: {}", bts::os::get_thread_id(), bts::os::get_thread_name(), msg_vec.size()); for (auto &m : msg_vec) { auto mtype = msg_type(m); LOG(OrderMan, Info, "SimExecutionGateway::send_msgs tid: {} tname: {} m_type: {}", bts::os::get_thread_id(), bts::os::get_thread_name(), mtype); me->buffered_order_ops.push(m); } } OnExeReport &SimExecutionGateway::on_exe_report() { return me->on_exe_report; } OnGwStatusChange &SimExecutionGateway::on_gw_status_change() { std::string tid_name = "SimExecutionGateway::_send_gw_status_once"; bts::threading::make_thread(tid_name, [&]() { _send_gw_status_once(); }).detach(); return me->on_gw_status_change; } OnCancelReject &SimExecutionGateway::on_cancel_reject() { return me->on_cancel_reject; } OnExchangePositionState &SimExecutionGateway::on_exchange_position_state() { return me->on_exchange_position_state; } OnExchangeOpenOrdersState &SimExecutionGateway::on_exchange_open_orders() { return me->on_exchange_open_orders; } void SimExecutionGateway::set_producers( md::GeneralSecurityIndex *producer_map) { LOG(OrderMan, Info, "SimExecutionGateway::set_producers exchange: {}", bts::api::Venue_Name(me->venue)); me->producer_map = producer_map; } void SimExecutionGateway::do_work() {} // this gets called by GeneralMarketDataListener, so this can alter the based on order activity bool SimExecutionGateway::get_matched_book( bts::md::SecurityKey k, std::array &out_bids, std::array &out_asks) { bts::SecurityKey key = k; // security entry is added here SEGSecurityData &seg_sec = *_find_add_security_entry(key, true, true); // this is where the book is updated to_book(out_bids, out_asks, seg_sec.real_book); if (seg_sec.orders.empty() && seg_sec.trades.empty() && me->buffered_order_ops.empty()) return false; // integrate the orders core::TimeStamp t1 = core::TimeStamp::now(); LOG(OrderMan, Diag, "SimExecutionGateway::get_matched_book this will result in a book " "calculation for key: {}", key.value()); me->touched_secs.insert(key); // handle buffered operations OrderMsg ord_msg; // all ord_msgs are popped and enqueued in the security's SEGSecurityData while (me->buffered_order_ops.try_pop(ord_msg)) { // LOG(OrderMan, Info, // "SimExecutionGateway::get_matched_book ord_msg dequeued from " // "get_matched_book, ord_msg: {}", // ord_msg); std::optional op_sec_key = _extract_sec_key(ord_msg); if (!op_sec_key.has_value()) { LOG(OrderMan, Error, "SimExecutionGateway::get_matched_book could not extract security " "from op: {}", ord_msg); continue; } // we could have used get_matched_book as the only source // of adding SEGSecurityData, but the line below adds it too // so both user operations and get_matched_book trigger // SEGSecurityData additions SEGSecurityData &op_seg_sec = *_find_add_security_entry(*op_sec_key, true, true); op_seg_sec.enqueue_action(ord_msg); me->touched_secs.insert(op_seg_sec.key); } // this takes care of everything ! _process_transaction(); from_book(seg_sec.matched_book, out_bids, out_asks); // cleanup for (SecurityKey key : me->touched_secs) { SEGSecurityData &t_seg_sec = *_find_add_security_entry(key, false, true); t_seg_sec.clear_after_transaction(); t_seg_sec.remove_inactive_orders(); } me->touched_secs.clear(); LOG(OrderMan, Diag, "SimExecutionGateway::get_matched_book time: {} ns key: {}", core::TimeStamp::now().nanos() - t1.nanos(), key); return true; } // subtracts all the trades that have happened against the book // (not self crosses) bts::orderman::Book reduce_book_by_trades(SEGSecurityData &seg_sec) { bts::orderman::Book rv = seg_sec.real_book; for (const auto &tr : seg_sec.trades) { rv = SpreaderUtils::remove_order(rv, {tr.price, tr.qty}); } return rv; } // this is where all the processing happens void SimExecutionGateway::_process_transaction() { // goes through all the actions and applies it to the orders (actions // take priority) for (SecurityKey key : me->touched_secs) { SEGSecurityData &sec_data = *_find_add_security_entry(key, false, true); while (!sec_data.pending_actions.empty()) { OrderMsg ord_msg = sec_data.pending_actions.front(); sec_data.pending_actions.pop(); auto [action_res, seg_os] = sec_data.apply_order_action(ord_msg); // any cxl and mods (and creates) that affected the order, result // in an er, which is fired here if (action_res != ActionResult::NoOp) { _push_execution_report(*seg_os); } } } // internally cross orders for (SecurityKey key : me->touched_secs) { SEGSecurityData &sec_data = *_find_add_security_entry(key, false, true); _internally_cross_orders(sec_data); } // now apply all the orders to the book (match) for (SecurityKey key : me->touched_secs) { SEGSecurityData &sec_data = *_find_add_security_entry(key, false, true); // this is (optionally) done so that the trades that happened in the past permenantly // have an affect on the book. bts::orderman::Book matched_bk = me->perm_reduce_book_by_trades ? reduce_book_by_trades(sec_data) : sec_data.real_book; // TODO: apply working orders first (or sort it by time) // (orders should be sorted) for (SEGOrderState &seg_os : sec_data.orders) { // if it was cancelled by the actions above, if (seg_os.active()) { // trades and execution reports are written along side matched_bk = _match_order(matched_bk, seg_os); } } sec_data.matched_book = matched_bk; _write_book(key); } } // this crosses the BTS generated orders agianst each other. this is done first // before the orders are crossed with the market book void SimExecutionGateway::_internally_cross_orders(SEGSecurityData &seg_sec) { auto try_cross_orders = [&](SEGOrderState &o1, SEGOrderState &o2) { if (o1.ord_key() == o2.ord_key()) return; if (!o1.active() || !o2.active()) return; if (o1.side() == o2.side()) return; bool is_cross = securities::is_equal_or_better(o1.side(), o1.price(), o2.price()); if (!is_cross) return; // TODO, get the best price auto o1_qty = o1.working_qty(); auto o2_qty = o2.working_qty(); auto crossed_qty = SpreaderUtils::cross_qtys(o1_qty, o2_qty); // TODO, we are crossing with our own orders first (FIFO not respected) o1.apply_fill(o1.price(), crossed_qty); _push_execution_report(o1); _write_trade(o1, o1.price(), crossed_qty); o2.apply_fill(o2.price(), crossed_qty); _push_execution_report(o2); _write_trade(o2, o2.price(), crossed_qty); }; // O(n^2), we can index it better and reduce it to O(n) for (SEGOrderState &o1 : seg_sec.orders) { for (SEGOrderState &o2 : seg_sec.orders) { try_cross_orders(o1, o2); } } } // We take an order and apply it to the book. As bts::orderman::Book SimExecutionGateway::_match_order( const bts::orderman::Book &book, SEGOrderState &seg_os) { if (!seg_os.active()) return book; double tick_sz = securities::market_epsilon(); auto crosses_opp_side = SpreaderUtils::crosses_book( book, seg_os.side(), bts::Price(seg_os.price()), tick_sz); if (crosses_opp_side) { return _cross_order(book, seg_os); } else { return _work_order(book, seg_os); } } // Given an order that is crossing (we know that from the callee), this // function does 3 things // 1. Generates a new book // 2. Adjust SEGOrderState's filled qty, status etc // 3. Generate execution report // 4. Generate trades and writes it to the MDProducer bts::orderman::Book SimExecutionGateway::_cross_order( const bts::orderman::Book &book, SEGOrderState &seg_os) { std::vector> fills = {}; auto rv = SpreaderUtils::apply_crossing_order( book, seg_os.side(), {seg_os.price(), seg_os.working_qty()}, fills); SEGSecurityData *seg_sec = _find_add_security_entry(seg_os.sec_key(), false, true); // this is where we need to do 2-4 for (const auto &[f_pr, f_qty] : fills) { seg_os.apply_fill(f_pr, f_qty); _push_execution_report(seg_os); _write_trade(seg_os, f_pr, f_qty); seg_sec->record_trade({seg_os.side(), f_pr, f_qty}); } return rv; } // Given an order that becomes a resting order (we know that from the callee), // this function does the following: // 1. Generates a new book // (Unlike the above, SEGOrderState's status does not need changing, neither // do we need to generate execution reports) bts::orderman::Book SimExecutionGateway::_work_order( const bts::orderman::Book &book, SEGOrderState &seg_os) { const BookSide &bside = book.side(seg_os.side()); Book rv = book; rv.side(seg_os.side()) = SpreaderUtils::apply_working_order( bside, seg_os.side(), {seg_os.price(), seg_os.working_qty()}); return rv; } // adds the security entry. this is called from get_book or when we // get a new order (also processed from within get_book) SEGSecurityData *SimExecutionGateway::_find_add_security_entry( SecurityKey security_key, bool add_if_absent, bool assert_for_presence) { auto find_add = [&]() -> SEGSecurityData * { auto it = me->books.find(security_key); if (it == me->books.end()) { if (!add_if_absent) { return nullptr; } LOG(OrderMan, Info, "SimExecutionGateway::_find_add_security_entry adding entry for " "sec: " "{}", security_key); me->books.insert({security_key, {security_key}}); it = me->books.find(security_key); } return &it->second; }; SEGSecurityData *rv = find_add(); if (assert_for_presence) bts_assert(rv != nullptr); return rv; } // fills execution report form SEGOrderState and writes it to // buffered_exec_reps, which is picked up from the other thread // and passed over to the order infrastructure void SimExecutionGateway::_push_execution_report(const SEGOrderState &seg_os) { ExecutionReport *er_p = me->exe_report_pool.construct(); ExecutionReport &er = *er_p; fill_execution_report(seg_os, er); me->buffered_exec_reps.push(er_p); } void SimExecutionGateway::_write_book(SecurityKey key) { SEGSecurityData &sec_data = *_find_add_security_entry(key, false, true); const Book &book = sec_data.matched_book; if (me->producer_map->has_security(key.value())) { auto idx_data = me->producer_map->get_security(key.value()); bts_assert(idx_data != nullptr); std::array bids, asks; from_book(book, bids, asks); idx_data->handle.update_direct(utils::TimeStamp::now(), bids, asks); } else { LOG(OrderMan, Error, "SimExecutionGateway::_write_book could not find handle for key: {}", key); } } void SimExecutionGateway::_write_trade( const SEGOrderState &seg_ord, Price price, Quantity qty) { auto key = seg_ord.sec_key().value(); if (me->producer_map->has_security(key)) { auto idx_data = me->producer_map->get_security(key); bts_assert(idx_data != nullptr); auto now = utils::TimeStamp::now(); auto trade_ts = datetime::ll_from_unix_epoch_ms(core::TimeStamp::now().millis()); idx_data->handle.add_trade( now, md::PriceSize(convert_price(price), qty.value()), trade_ts, // TODO co2::AggressorSide::AGGRESSOR_SIDE_BUY, 0, false); } else { LOG(OrderMan, Error, "SimExecutionGateway::_write_trade could not find handle for key: {}", key); } } std::tuple SimExecutionGateway::_find_order(OrderKey key) const { for (const auto &kv : me->books) { for (const auto &ord : kv.second.orders) { if (ord.ord_key() == key) { return {&kv.second, &ord}; } } } return std::tuple( nullptr, nullptr); } void SimExecutionGateway::_send_gw_status_once() { auto sleep_period = std::chrono::milliseconds(2500); std::this_thread::sleep_for(sleep_period); // fire the status and exit the thread me->on_gw_status_change(true); } // this returns the security key from an OrdMsg. The reason it has more code // than needed is because CancelOrderMsg might not have the security set. // therefore we need to find the security from the order key std::optional SimExecutionGateway::_extract_sec_key( const OrderMsg &msg) { if (std::holds_alternative(msg)) { const CreateOrderMsg &cr_msg = std::get(msg); return SecurityKey(cr_msg.security->id()); } else if (std::holds_alternative(msg)) { const CancelReplaceOrderMsg &cxlr_msg = std::get(msg); return SecurityKey(cxlr_msg.create_fields.security->id()); } else if (std::holds_alternative(msg)) { const CancelOrderMsg &cxl_msg = std::get(msg); if (cxl_msg.security != nullptr) { return SecurityKey(cxl_msg.security->id()); } auto [sec, ord] = _find_order(cxl_msg.key); if (sec == nullptr || ord == nullptr) { return std::nullopt; } return sec->key; } else if (std::holds_alternative(msg)) { const RFQMsg &rfq_msg = std::get(msg); return SecurityKey(rfq_msg.rfq.security().security_id()); } return SecurityKey(0); } // generates an execution rerport from SEGOrderState void fill_execution_report(const SEGOrderState &seg_os, ExecutionReport &er) { const auto &cr_msg = seg_os.crt_msg; log_ord_msg("fill_execution_report", cr_msg); to_array(cr_msg.routing_record->account(), &er.account_name.value()); to_array(cr_msg.routing_record->operator_id(), &er.operator_id.value()); er.order_key = cr_msg.key; er.msg_seq_num = 0; er.security = cr_msg.security; er.leg_security = nullptr; er.side = cr_msg.side; er.time_in_force = cr_msg.time_in_force; er.order_type = cr_msg.order_type; er.exec_type = api::orderman::ExecType::EXEC_TYPE_NEW; er.order_status = seg_os.status; er.manual_order_indicator = api::orderman::ManualOrderIndicator::MANUAL_ORDER_INDICATOR_NO; std::string exch_oid = std::to_string(cr_msg.key.value()); auto &er_exch_oid = std::get(er.exchange_order_id).value(); to_array(exch_oid, &er_exch_oid); er.price.value() = seg_os.price().value(); er.quantity = seg_os.qty(); // fractional qty // fills er.avg_price.value() = seg_os.avg_filled_price.value(); er.filled_quantity = seg_os.filled_qty; er.last_shares = seg_os.last_filled_qty; er.last_price = seg_os.last_filled_price; if (!seg_os.last_filled_qty.is_zero()) { bts::utils::Uuid guid; std::string fill_id = guid.to_text_string(); to_array(fill_id, &er.exchange_fill_id.value()); er.exec_type = api::orderman::EXEC_TYPE_PARTIAL_FILL; if (!seg_os.active()) { er.exec_type = api::orderman::EXEC_TYPE_FILL; } } er.max_show = Quantity(0); er.exchange = cr_msg.security->exchange(); ExchangeTimeStamp64 now = ExchangeTimeStamp64(datetime::unix_nano_now()); er.transact_time = now; LOG(OrderMan, Info, "EMExecutionGateway::_process_cb_and_fire_er firing er: {}", er.to_string()); } } // namespace bts::orderman