#include "EMNativeOrder.h" #include "lib/api/services/OrderService.pb.h" #include "lib/config/config.h" #include "lib/config/protos/orderman_cfg.pb.h" #include "lib/config/protos/toggles.pb.h" #include "lib/domain/OrderStatus.h" #include "lib/domain_model/Security.h" #include "lib/domain_model/common.h" #include "lib/jetfix/codec/FIXFragment.h" #include "lib/jetfix/codec/FieldDefinitions.h" #include "lib/logging/logging.h" #include "lib/orderman/CancelOrderMsg.h" #include "lib/orderman/CancelReplaceOrderMsg.h" #include "lib/orderman/CreateOrderMsg.h" #include "lib/orderman/OrderRouter.h" #include "lib/orderman/OrderServices.h" #include "lib/orderman/order_factory/IOrderFactory.h" #include "lib/orderman/orderman_utils/ExecutionReport.h" #include "lib/orderman/orderman_utils/fix_order_codec.h" #include "lib/orderman/orderman_utils/orderman_common.h" #include "lib/orderman/orders/OrderOpResult.h" #include "lib/orderman/orders/PreActivationOrderServices.h" #include "lib/orderman/orders/algo/IAlgoOrder.h" #include "lib/orderman/orders/glbx/IGLBXOrderEncoder.h" #include "lib/orderman/orders/glbx/iLink2OrderEncoder.h" #include "lib/orderman/orders/glbx/iLink3OrderEncoder.h" #include "lib/orderman/securities/ISecurityDB.h" #include "lib/os/os.h" #include "lib/utils/PBUtils.h" #include "lib/utils/bts_assert.h" #include "lib/utils/bts_chrono.h" #include "server/sparkd/md/platforms/emumba/EmMDListener.h" #include #include #include #include namespace bts { namespace orderman { using namespace api::orderman; struct EMNativeOrder::PImpl { PImpl() : services(nullptr), session_services(), sec(nullptr), previous_working_position(0), definition(), state(), exchange_order_id() {} bool inited = false; OrderServices *services; SessionServices *session_services; const api::Security *sec; Quantity previous_working_position; OrderDefinition definition; OrderState state; std::optional exchange_order_id; OrderServices::ExeReportSubID exe_report_sid; OrderServices::CancelRejectSubID cancel_reject_sid; bool buffered_cancel = false; std::optional buffered_update; RoutingRecord routing_record; }; EMNativeOrder::EMNativeOrder() : me(new PImpl()) { LOG(OrderMan, Info, "EMNativeOrder::EMNativeOrder t_id: {} t_name: {}", os::get_thread_id(), os::get_application_name()); } EMNativeOrder::~EMNativeOrder() {} api::orderman::OrderDefinition const &EMNativeOrder::definition() const { return me->definition; } // Construction, the order is not yet live and it may never // be. This can be slow. This is the first call void EMNativeOrder::on_init_new( api::orderman::OrderDefinition const &def, const PreActivationOrderServices &serv) { bts_assert(!me->inited); me->inited = true; LOG(OrderMan, Info, "EMNativeOrder::on_init_new key: {} sec_key: {} user: {} account: {}", key(), def.security_key(), def.user(), def.account()); me->definition = def; me->sec = serv.sec_db.resolve(SecurityKey(def.security_key())); // Check for invariants, if not met, reject the order // 1. Sec can be resolved // 2. Order is either Limit or Market // 3. Routing Record can be constructed (serv.order_router.get_routing_record // returns a valid record) // Else, transition to ORDER_STATUS_INACTIVE, and set native state if (!me->sec) { auto msg = fmt::format("Unknown security: {}", def.security_key()); me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } switch (def.custom_def().custom_case()) { case CustomOrderDefinition::kMarket: me->state.mutable_market(); break; case CustomOrderDefinition::kLimit: me->state.mutable_limit(); break; default: { auto msg = "Order type not supported at this venue"; me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } } switch (def.time_in_force()) { case TIME_IN_FORCE_DAY: case TIME_IN_FORCE_IOC: case TIME_IN_FORCE_GTC: break; default: { auto msg = "Time In Force not supported at this venue"; me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } } auto rq = serv.order_router.get_routing_record( UserID(def.user_id()), AccountID(def.account_id()), *me->sec); if (!rq.has_route) { auto msg = fmt::format("Could not route order: {}", rq.error_msg); LOG(OrderMan, Error, "{}", msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } // Successful order always starts in ORDER_STATUS_INACTIVE transition(ORDER_STATUS_INACTIVE); auto &native_state = get_native_state(me->state); me->routing_record = rq.routing_record; *native_state.mutable_routing_record() = rq.routing_record; LOG(OrderMan, Info, "EMNativeOrder::on_init_new key: {} routing_record: {}", key(), utils::pb::to_string(me->routing_record)); } // We dont recover order. So if it is non terminal, we mark it as error void EMNativeOrder::on_init_recovered( api::orderman::OrderRecord const &rec, const PreActivationOrderServices &serv) { bts_assert(!me->inited); me->inited = true; me->definition = rec.def(); me->state = rec.state(); me->sec = serv.sec_db.resolve(SecurityKey(me->definition.security_key())); me->previous_working_position = Quantity(0); LOG(OrderMan, Info, "EMNativeOrder::on_init_recovered key: {} sec_id: {} status: {} " "t_id: " "{} t_name: {}", key(), me->sec == nullptr ? 0 : me->sec->id(), OrderStatus_Name(me->state.status()), os::get_thread_id(), os::get_application_name()); if (in_terminal_state(rec.state().status())) { transition(rec.state().status()); } else transition( OrderStatus::ORDER_STATUS_ERROR, "Recovered Orders are not handled"); } OrderOpResult EMNativeOrder::on_activate( Price p, Quantity q, OrderServices &services) { bts_assert(me->inited); LOG(OrderMan, Info, "EMNativeOrder::on_activate key: {} p: {} q: {}", key(), p, q); bts_assert(!me->services); me->services = &services; auto result = OrderOpResult{}; switch (me->state.status()) { case ORDER_STATUS_INACTIVE: { // this is a brand new order // _on_activate sets the price, quantity result = _on_activate(Warn, Info, p, q, services); if (result.ok()) { CreateOrderMsg c_msg = {}; _create_create_msg(c_msg); transition(ORDER_STATUS_PENDING_WORKING); me->services->queue_order_msg(*me->session_services, c_msg); me->services->governor(*me->session_services).record_sent(); LOG(OrderMan, Info, "EMNativeOrder::on_activate sent new order with key {} to " "gateway", key().value()); // Early return so we skip the expensive report_state() // call. It is OK to skip it because we are bound to report // our state once the excange acknowledges the order. update_working_position(); return OrderOpResult{}; } else { report_state(); return result; } } // control will only reach here if on_init_new failed, or it was a // recovered order, in which case we are already in a terminal state, // hence nothing to default: bts_assert(in_terminal_state(me->state.status())); break; } report_state(); return result; } OrderOpResult EMNativeOrder::on_update(Price p, Quantity q) { LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}", key().value(), p, q); api::orderman::Update update; update.set_price(p.value()); update.set_quantity(q.value()); update.mutable_fractional_quantity()->set_fraction(q.fractional_part()); return on_update(update); } OrderOpResult EMNativeOrder::on_update(api::orderman::Update const &update) { LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} update: {}", key().value(), utils::pb::to_string(update)); auto new_p = Price(update.price()); auto new_q = bts::orderman::get_update_quantity(update); LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}", key().value(), new_p, new_q); auto result = OrderOpResult{}; // the only state where we consider an update is ORDER_STATUS_WORKING switch (me->state.status()) { case ORDER_STATUS_WORKING: { auto curr_working_qty = working_position(); auto potential_working_qty = 0; if (new_q.value() > me->state.filled_quantity()) potential_working_qty = new_q.value() - me->state.filled_quantity(); auto lqr = me->services->limiter().can_update_order( AccountID(me->definition.account_id()), *me->sec, me->definition.side(), Quantity(curr_working_qty), Quantity(potential_working_qty)); lqr.result = Limiter::OK; // are we under the position limits? if (!lqr.ok()) { auto msg = fmt::format( "Cannot update order due to limit breach: {}", lqr.error_msg); LOG(OrderMan, Error, "Order update failed due to limit breach. Order: {} Msg: {}", key().value(), lqr.error_msg); ignore_or_cancel(msg, ORDER_ERROR_LIMIT_BREACH, &result); break; } // are we under the messaging threshold? if (!me->services->governor(*me->session_services).can_send()) { LOG(OrderMan, Warn, "Cannot update order {} because of messaging limits. ", key().value()); auto msg = "Messaging threshold breached"; ignore_or_cancel(msg, ORDER_ERROR_MESSAGING_LIMIT_BREACH, &result); break; } CancelReplaceOrderMsg cxl_repl_msg = {}; _create_create_msg(cxl_repl_msg.create_fields); cxl_repl_msg.create_fields.price = new_p; cxl_repl_msg.create_fields.quantity = new_q; me->services->queue_order_msg(*me->session_services, cxl_repl_msg); me->services->governor(*me->session_services).record_sent(); update_working_position(); if (me->state.last_msg().size()) me->state.set_last_msg(""); // early return so we skip report_state (for speed) (an execution // report should take care of it?) return OrderOpResult{}; } // anytime we disconnect we go to error and let the execution gwy take // care of it case ORDER_STATUS_DISCONNECTED: bts_assert(false); break; case ORDER_STATUS_PENDING_WORKING: LOG(OrderMan, Warn, "Cannot apply update to order {}. Update: {}@{}. Buffering", key().value(), update.quantity(), update.price()); me->buffered_update.emplace(update); break; // terminal states, nothing to do case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: break; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); return result; } OrderOpResult EMNativeOrder::on_detach() { return {}; } OrderOpResult EMNativeOrder::on_cancel() { LOG(OrderMan, Info, "EMNativeOrder::on_cancel key: {}", key()); auto result = OrderOpResult{}; switch (me->state.status()) { // the only state where a cancel is sent out case ORDER_STATUS_WORKING: { // TODO, CancelOrderMsg is not completely filled CancelOrderMsg cxl_msg = {}; cxl_msg.key = key(); LOG(OrderMan, Info, "EMNativeOrder queue_order_msg for cxl"); me->services->queue_order_msg(*me->session_services, cxl_msg); break; } // already in a terminal state, nothing to do case ORDER_STATUS_CANCELED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_ERROR: break; case ORDER_STATUS_PENDING_WORKING: { // we buffer this, and as soon as we get the exchnage id, we cxl it me->buffered_cancel = true; LOG(OrderMan, Warn, "Cannot cancel order {} while in the pending working state. " "Buffering cancel", key().value()); break; } case ORDER_STATUS_DISCONNECTED: { me->buffered_cancel = true; LOG(OrderMan, Warn, "Cannot cancel order {} while in the disconnected state. " "Buffering " "cancel", key().value()); auto msg = "Order will be canceled when re-connected"; result.error = ORDER_ERROR_GATEWAY_NOT_READY; result.error_msg = msg; // to print the message transition(me->state.status(), msg); break; } case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); return result; } void EMNativeOrder::on_attached(api::orderman::OrderDefinition const &) { // TODO } api::orderman::OrderDefinition EMNativeOrder::on_init_from_exe_report( ExecutionReport const &, const PreActivationOrderServices &) { // TODO return me->definition; } void EMNativeOrder::warm_up_activate(OrderServicesData &, OrderServices &) {} void EMNativeOrder::transition( api::orderman::OrderStatus new_status, std::string const &msg) { transition(Info, new_status, msg); } void EMNativeOrder::transition( log::Level level, api::orderman::OrderStatus new_status, std::string const &msg) { auto const &from = OrderStatus_Name(me->state.status()); auto const &to = OrderStatus_Name(new_status); if (from != to) LOG(OrderMan, level, "Transitioning order {} from {} to {}. Msg: {}", key().value(), from, to, msg); me->state.set_status(new_status); me->state.set_last_msg(msg); } void EMNativeOrder::transition(api::orderman::OrderStatus new_status) { auto const &from = OrderStatus_Name(me->state.status()); auto const &to = OrderStatus_Name(new_status); if (from != to) LOG(OrderMan, Info, "Transitioning order {} from {} to {}", key().value(), from, to); else LOG(OrderMan, Diag, "Transitioning order {} from {} to {}", key().value(), from, to); me->state.set_status(new_status); } void EMNativeOrder::update_working_position() { if (me->sec) { auto current_position = working_position(); auto previous_position = me->previous_working_position; me->previous_working_position = current_position; if (current_position.value() > previous_position.value()) me->services->limiter().add_to_working_position( *me->sec, AccountID(me->definition.account_id()), me->definition.side(), Quantity(current_position.value() - previous_position.value())); else if (previous_position.value() > current_position.value()) me->services->limiter().remove_from_working_position( *me->sec, AccountID(me->definition.account_id()), me->definition.side(), Quantity(previous_position.value() - current_position.value())); } else LOG(OrderMan, Error, "Order {} ignored for purposes of limit enforcing " "because it references unknown security {} ", key().value(), me->definition.security_key()); } // Returns the open position for a working order. If there are fills, // returns the difference Quantity EMNativeOrder::working_position() { switch (me->state.status()) { // working case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_DISCONNECTED: if (me->state.quantity() > me->state.filled_quantity()) return Quantity(me->state.quantity() - me->state.filled_quantity()); else return Quantity(0); // terminal case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_ERROR: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: return Quantity(0); case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); return Quantity(0); } bts_assert(false); return Quantity(0); } void EMNativeOrder::report_state() { update_working_position(); LOG(OrderMan, Info, "EMNativeOrder::report_state state: {}", utils::pb::to_string(me->state)); me->services->report_state(me->state); } OrderOpResult EMNativeOrder::_on_activate( log::Level reject_level, log::Level transition_level, Price p, Quantity q, bts::orderman::OrderServices & /*order_services*/) { LOG(OrderMan, Info, "EMNativeOrder::_on_activate p: {} q: {}", p, q); // update state wrt price, qty, fills me->state.set_price(p.value()); bts::orderman::set_quantity(me->state, StateQuantityType::OrderQuantity, q); me->state.set_filled_quantity(0); me->state.set_last_price(0); me->state.set_avg_price(0); me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session()); // TODO: just to get going me->session_services = &me->services->get_session_services("deribit_em"); // Checks for the following: // 1. Gateway connection // 2. Risk (can_trade, clip, position) // 3. Governor (orders/sec) // If any of the above fail, it goes to terminal state // (ORDER_STATUS_REJECTED_BY_SPARK) abd returns error // Else, subscribes to service events (including execution report) if (!_is_gateway_connected(me->session_services)) { LOG(OrderMan, reject_level, "Attempt to send order to a disconnected gateway. " "Dropping order {}", key().value()); auto msg = "Exchange gateway is down"; transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult{ORDER_ERROR_GATEWAY_NOT_READY, msg}; } // this is to skip risk limits for options bool turn_risk_off = false; // me->sec->has_option() || me->sec->has_future(); // the following consults the limiter // can the user trade ? auto lqr = me->services->limiter().can_trade( UserID(me->definition.user_id()), AccountID(me->definition.account_id())); if (turn_risk_off) { lqr.result = Limiter::LimiterErrorCode::OK; } if (!lqr.ok()) { LOG(OrderMan, reject_level, "Unauthorized order attempted. User: {} on " "Account: {}. Msg: {} Order: {}. Dropping order", me->definition.user(), me->definition.account(), lqr.error_msg, key().value()); auto msg = fmt::format("Unauthorized order: {}", lqr.error_msg); transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult{ORDER_ERROR_UNAUTHORIZED, msg}; } // risk limits (clip size, position) lqr = me->services->limiter().can_send_new_order( AccountID(me->definition.account_id()), *me->sec, me->definition.side(), q); if (turn_risk_off) { lqr.result = Limiter::LimiterErrorCode::OK; } if (!lqr.ok()) { LOG(OrderMan, reject_level, "New order would breach limit. User: {} Account: " "{} Msg: {} Order: {}. Dropping order", me->definition.user(), me->definition.account(), lqr.error_msg, key().value()); auto msg = fmt::format("Order would breach limit: {}", lqr.error_msg); transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult{ORDER_ERROR_LIMIT_BREACH, msg}; } // are we under the messaging threshold? (governor limits) if (!me->services->governor(*me->session_services).can_send()) { LOG(OrderMan, reject_level, "New order would cause breach of messaging " "limits. Dropping order {}", key().value()); auto msg = "Messaging threshold breached"; transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult(ORDER_ERROR_MESSAGING_LIMIT_BREACH, msg); } me->exe_report_sid = me->services->subscribe_to_exe_report( *me->session_services, key(), [this](auto const &r) { this->_on_exe_report(r); }); me->cancel_reject_sid = me->services->subscribe_to_cancel_reject( *me->session_services, key(), [this](auto const &cr) { LOG(OrderMan, Error, "CancelReject received for order: {} msg: {}", key(), cr.reject_msg()); }); me->services->subscribe_to_gateway_status( *me->session_services, [this](auto const &gw) { // gateway will cancel all orders if (!gw.is_connected) { transition( api::orderman::OrderStatus::ORDER_STATUS_ERROR, "Connection to gateway lost"); report_state(); } }); LOG(OrderMan, Info, "EMNativeOrder::_on_activate sucessful key: {}", key()); LOG(OrderMan, Info, "EMNativeOrder::_on_activate state: {}", utils::pb::to_string(me->state)); return OrderOpResult{}; } // OrderState's CustomOrderState has some OrderStates' corresponding to // NativeOrder (ex MarketOrderState, LimitOrderState etc). Each of these // special OrderStates have NativeOrderState - this function plucks that out api::orderman::NativeOrderState &EMNativeOrder::get_native_state( api::orderman::OrderState &st) { switch (st.custom_case()) { case OrderState::kMarket: return *st.mutable_market()->mutable_native_state(); case OrderState::kLimit: return *st.mutable_limit()->mutable_native_state(); default: break; } bts_assert(false); return *st.mutable_limit()->mutable_native_state(); } NativeOrderType get_native_ord_type(const OrderDefinition &def) { switch (def.custom_def().custom_case()) { case CustomOrderDefinition::kMarket: return NativeOrderType::NATIVE_ORDER_TYPE_MARKET; break; case CustomOrderDefinition::kLimit: return NativeOrderType::NATIVE_ORDER_TYPE_LIMIT; break; default: break; } bts_assert(false); return api::orderman::NATIVE_ORDER_TYPE_LIMIT; } void EMNativeOrder::_create_create_msg(CreateOrderMsg &c) { c.key = key(); c.price = Price(me->state.price()); c.quantity = bts::orderman::get_quantity(me->state, StateQuantityType::OrderQuantity); c.security = me->sec; c.side = me->definition.side(); c.order_type = get_native_ord_type(me->definition); c.time_in_force = me->definition.time_in_force(); c.order_type = api::orderman::NATIVE_ORDER_TYPE_LIMIT; c.manual_order_indicator = me->definition.manual_order_indicator(); c.routing_record = &me->routing_record; LOG(OrderMan, Info, "EMNativeOrder::_create_create_msg c.qty: {}", c.quantity); } void EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) { LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report key: {} er: {}", key(), er.data->to_string()); auto &state = me->state; // we dont care for the native status in EM, for backwards compatibility's // sake updating it auto &native_state = get_native_state(state); native_state.set_last_msg_seq_num(er.data->msg_seq_num); native_state.set_native_status(er.data->order_status); native_state.set_native_type(er.data->order_type); set_last_transact_time(er.data->transact_time, &native_state); // This status is inferred from the er OrderStatus er_status = get_external_status(er.data->order_status); bts_assert( er_status == OrderStatus::ORDER_STATUS_WORKING || er_status == OrderStatus::ORDER_STATUS_CANCELED || er_status == OrderStatus::ORDER_STATUS_COMPLETED || er_status == OrderStatus::ORDER_STATUS_ERROR); state.set_last_msg(er.data->msg); auto _absorb_er = [this, &er, &er_status]() { // this is not set in on_update, but only set when the exchange ack's it me->state.set_price(er.data->price.value()); // me->state.set_quantity(er.data->quantity.value()); bts::orderman::set_quantity( me->state, StateQuantityType::OrderQuantity, er.data->quantity); _absorb_fill(*er.data); transition(er_status); }; switch (me->state.status()) { case api::orderman::ORDER_STATUS_INACTIVE: // as soon an order is sent we leave this state, so there is no way we // should get an er while in this state bts_assert(false); break; // terminal state already, nothing to do case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: LOG(OrderMan, Error, "Received er: {} for key: {} while in terminal state", er.data->to_string(), key()); break; // the only 2 states that handle execution report are // ORDER_STATUS_WORKING and ORDER_STATUS_PENDING_WORKING case api::orderman::ORDER_STATUS_WORKING: _absorb_er(); break; case ORDER_STATUS_PENDING_WORKING: _absorb_er(); if (in_terminal_state(er_status)) { break; } bts_assert(er_status == OrderStatus::ORDER_STATUS_WORKING); if (me->buffered_cancel) { LOG(OrderMan, Warn, "Applying buffered cancel to order {}, on first ack", key().value()); on_cancel(); } else if (me->buffered_update.has_value()) { auto update = me->buffered_update.value(); me->buffered_update.reset(); LOG(OrderMan, Warn, "Applying buffered update ({}@{}) to order {}, on " "first ack", update.quantity(), update.price(), key().value()); on_update(update); } break; case ORDER_STATUS_DISCONNECTED: // will never be in this state case ORDER_STATUS_REJECTED_BY_SPARK: // it only gets rejected before the order is sent, so similiar to // inactive, we should never get an er here case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); } bool EMNativeOrder::_is_gateway_connected(SessionServices *) const { return true; } void EMNativeOrder::ignore_or_cancel( std::string const &msg, api::orderman::OrderError error, OrderOpResult *out) { if (parent_key() == null_order_key()) transition(me->state.status(), msg); else { me->state.set_last_msg(msg); on_cancel(); } *out = {error, msg}; } Quantity EMNativeOrder::_working_qty() const { auto rv = Quantity(0); if (me->state.quantity() > me->state.filled_quantity()) { rv = Quantity(me->state.quantity() - me->state.filled_quantity()); } return rv; } void EMNativeOrder::_absorb_fill(const ExecutionReport &er) { if (er.last_shares > Quantity(0, 0)) { bts::orderman::set_quantity( me->state, StateQuantityType::FilledQuantity, er.filled_quantity); me->state.set_avg_price(er.avg_price.value()); me->state.set_last_price(er.last_price.value()); } } } // namespace orderman } // namespace bts