#include "TriggerOrder.h" #include "lib/domain_model/Security.h" #include "lib/logging/logging.h" #include "lib/orderman/actors/order_manager/OrderBuilder.h" #include "lib/orderman/events/BookUpdateEvent.h" #include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" #include "lib/os/os.h" #include "lib/utils/PBUtils.h" #include "lib/orderman/orders/PreActivationOrderServices.h" #include #include namespace bts { namespace orderman { struct TriggerOrder::PImpl { OrderServices *services; api::orderman::OrderDefinition order_def; double tick_size; // true if timeout_exit is enabled bool timeout_exit; uint32_t timeout_msecs; // true position cond exit is enabled bool price_cond_exit; api::orderman::OrderState state; // child state copied directly from the // child order udpate callback api::orderman::OrderState child_state; OrderBuilder order_builder; ChildOrder child_order; // true if child order has been placed once bool order_placed; Book book; CancelMode cancel_mode; // this tells that when the order is placed // initially, if the trigger price above the // market (trigger_condition's chosen market) bool trigger_above_market; // true is non 0 market corresponding // to the trigger market is obs'ed once bool market_observed_once; bool is_recovered; bool is_succ_inited; bts::TimeStamp child_order_time; PImpl() : services(nullptr), order_def(), timeout_exit(false), timeout_msecs(std::numeric_limits::max()), price_cond_exit(false), state(), child_state(), child_order(), order_placed(false), book(), cancel_mode(CancelMode::none), market_observed_once(false), is_recovered(false), is_succ_inited(false) {} }; TriggerOrder::TriggerOrder() : _state(State::START), me(new PImpl()) {} TriggerOrder::~TriggerOrder() {} const api::orderman::OrderDefinition &TriggerOrder::definition() const { return me->order_def; } void TriggerOrder::on_init_new(const api::orderman::OrderDefinition &order_def, const PreActivationOrderServices &pre_os) { LOG(OrderMan, Info, "TriggerOrder::on_init_new key:{} state:{}", key(), _state); switch (_state) { case State::START: me->is_succ_inited = _on_init_new(order_def, pre_os); break; case State::WAITING_FOR_TRIGGER: case State::WAITING_FOR_FIRST_ACK: case State::STEADY: case State::END: std::ostringstream oss; oss << "TriggerOrder::on_init_new key:" << key() << "state:" << _state; bts_assert_msg(false, oss.str()); break; } } void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord &rec, const PreActivationOrderServices &pre_os) { LOG(OrderMan, Info, "TriggerOrder::on_init_recovered key:{} state:{}", key(), _state); switch (_state) { case State::START: me->is_succ_inited = _on_init_new(rec.def(), pre_os); // get the state from what was recovered (we will only use // it for reporting) me->state = rec.state(); // if it was not in a terminal state, we will call it cancelled if (!SpreaderUtils::order_in_terminal_state(me->state.status())) me->state.set_status( api::orderman::OrderStatus::ORDER_STATUS_CANCELED); me->is_recovered = true; break; case State::WAITING_FOR_TRIGGER: case State::WAITING_FOR_FIRST_ACK: case State::STEADY: case State::END: std::ostringstream oss; oss << "TriggerOrder::on_init_recovered key:" << key() << "state:" << _state; bts_assert_msg(false, oss.str()); break; } } OrderOpResult TriggerOrder::on_activate(Price price, Quantity qty, OrderServices &services) { LOG(OrderMan, Info, "TriggerOrder::on_activate key:{} state:{} price:{} qty:{}", key(), _state, price, qty); switch (_state) { case State::START: me->services = &services; me->state.set_price(price.value()); me->state.set_quantity(qty.value()); if (me->is_recovered || !me->is_succ_inited) _switch_state(State::END); else { me->order_builder.activate(services); me->child_order = me->order_builder.build(); services.subscribe_to_child_updates( [this](const OrderStateUpdateEvent &os) { this->_on_child_order_update(os); }); services.subscribe_to_book(SecurityKey(me->order_def.security_key()), [this](const BookUpdateEvent &bk_event) { this->_on_book_update(bk_event); }); services.subscribe_to_time( [this](const bts::mercury::TimerEvent &te) { _on_time(te); }); _switch_state(State::WAITING_FOR_TRIGGER); } break; case State::WAITING_FOR_TRIGGER: case State::WAITING_FOR_FIRST_ACK: case State::STEADY: case State::END: { std::ostringstream oss; oss << "TriggerOrder::on_activate key:" << key() << "state:" << _state; bts_assert_msg(false, oss.str()); break; } } return OrderOpResult{}; } // order price, qty change OrderOpResult TriggerOrder::on_update(Price price, Quantity qty) { LOG(OrderMan, Info, "TriggerOrder::on_update key:{} state:{} price:{} qty:{}", key(), _state, price, qty); switch (_state) { case State::START: me->state.set_price(price.value()); me->state.set_quantity(qty.value()); // cant report because does not have order_services yet break; case State::WAITING_FOR_TRIGGER: me->state.set_price(price.value()); me->state.set_quantity(qty.value()); _report_state(); _analyze_trigger_and_shoot(); break; case State::WAITING_FOR_FIRST_ACK: case State::STEADY: me->state.set_last_msg( "Trigger order can not be modified after the trigger has been hit"); _report_state(); break; case State::END: break; } return OrderOpResult{}; } OrderOpResult TriggerOrder::on_cancel() { LOG(OrderMan, Info, "TriggerOrder::on_cancel key:{} state:{}", key(), _state); me->cancel_mode = CancelMode::external; switch (_state) { case State::START: _switch_state(State::END); break; case State::WAITING_FOR_TRIGGER: _switch_state(State::END); break; case State::WAITING_FOR_FIRST_ACK: // we dont have a WAITING_FOR_ACK_CANCELLED // (like the Quoter), so this message is // rejected and reported me->state.set_last_msg("Order is in flight"); _report_state(); break; case State::STEADY: _cancel_order(CancelMode::external); break; case State::END: break; } return OrderOpResult{}; } void TriggerOrder::_on_book_update(const BookUpdateEvent &b_event) { switch (_state) { case State::START: break; case State::WAITING_FOR_TRIGGER: if (b_event.key().value() == me->order_def.security_key()) { me->book = b_event.book; _observe_market_once(); _analyze_trigger_and_shoot(); } break; case State::WAITING_FOR_FIRST_ACK: break; case State::STEADY: if (b_event.key().value() == me->order_def.security_key()) { if (me->price_cond_exit) { me->book = b_event.book; _analyze_trigger_and_cancel(); } } case State::END: break; } } void TriggerOrder::_on_child_order_update(const OrderStateUpdateEvent &o_ev) { if (o_ev.key == me->child_order.key()) { auto ev_state = o_ev.rebuild_state(); me->child_state = ev_state; switch (_state) { case State::START: case State::WAITING_FOR_TRIGGER: bts_assert(false); break; case State::WAITING_FOR_FIRST_ACK: if (SpreaderUtils::order_acknowledged(o_ev.status)) { if (SpreaderUtils::order_in_terminal_state(o_ev.status)) _switch_state(State::END); else _switch_state(State::STEADY); } break; case State::STEADY: if (SpreaderUtils::order_in_terminal_state(ev_state.status())) _switch_state(State::END); break; case State::END: break; } _report_state(); } } void TriggerOrder::_on_time(const bts::mercury::TimerEvent &) { switch (_state) { case State::START: case State::WAITING_FOR_TRIGGER: case State::WAITING_FOR_FIRST_ACK: break; case State::STEADY: { if (me->timeout_exit) _analyze_trigger_and_cancel(); break; } case State::END: break; } } bool TriggerOrder::_on_init_new(const api::orderman::OrderDefinition &order_def, const PreActivationOrderServices &pre_os) { me->order_def = order_def; if (!me->order_def.has_custom_def() || !me->order_def.custom_def().has_trigger()) { LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " "OrderDefinition does not have TriggerOrderDefinition", key(), _state); me->state.set_last_msg("Trigger Order not properly formed"); return false; } if (pre_os.sec_db.resolve(SecurityKey(order_def.security_key())) == nullptr) { LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " "Could not resolve sec_key:{}", key(), _state, order_def.security_key()); me->state.set_last_msg("Could not resolve Trigger Order security"); return false; } const auto &trigger_order_def = order_def.custom_def().trigger(); if (pre_os.sec_db.resolve(SecurityKey( trigger_order_def.trigger_action().security_id())) == nullptr) { LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " "Could not resolve child key sec_key:{}", key(), _state, trigger_order_def.trigger_action().security_id()); me->state.set_last_msg("Could not resolve Trigger Order child security"); return false; } if (!trigger_order_def.trigger_action().has_payup() && bts::os::is_nan(trigger_order_def.trigger_action().price())) { LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " "illegal child order price", key(), _state); me->state.set_last_msg("Illegal Child Order price"); return false; } me->timeout_exit = trigger_order_def.has_exit_condition() && trigger_order_def.exit_condition().timeout_enabled(); me->timeout_msecs = trigger_order_def.has_exit_condition() ? 1000.0 * trigger_order_def.exit_condition().timeout_seconds() : std::numeric_limits::max(); me->price_cond_exit = trigger_order_def.has_exit_condition() && trigger_order_def.exit_condition().conditional_cancel(); api::orderman::OrderDefinition child_order_def = order_def; child_order_def.set_security_key( trigger_order_def.trigger_action().security_id()); child_order_def.mutable_custom_def()->CopyFrom(trigger_order_def.child()); me->order_builder = OrderBuilder(key(), child_order_def, pre_os.order_factory); const auto *sec_ptr = pre_os.sec_db.resolve(SecurityKey(order_def.security_key())); me->tick_size = std::min(sec_ptr->contract_spec().low_tick(), sec_ptr->contract_spec().high_tick()); LOG(OrderMan, Info, "TriggerOrder::_on_init_new key:{} state:{} " "trigger_price_type:{} child_order_price:{}", key(), _state, trigger_order_def.trigger_condition().price_type(), trigger_order_def.trigger_action().price()); return true; } void TriggerOrder::_report_state() { if (_activated()) { _compute_state(); me->services->report_state(me->state); } } void TriggerOrder::_switch_state(State new_state) { switch (new_state) { case State::START: break; case State::WAITING_FOR_TRIGGER: bts_assert(_state == State::START); break; case State::WAITING_FOR_FIRST_ACK: bts_assert(_state == State::WAITING_FOR_TRIGGER); break; case State::STEADY: bts_assert(_state == State::WAITING_FOR_FIRST_ACK); break; case State::END: bts_assert(_state != State::END); break; } LOG(OrderMan, Info, "TriggerOrder::_report_state key:{} {}->{}", key(), _state, new_state); _state = new_state; _report_state(); } void TriggerOrder::_analyze_trigger_and_shoot() { if (me->market_observed_once) { double trigger_price = _trigger_price(); const md::PriceSize *obs_md = _observed_market(); if (_trigger_met(obs_md, trigger_price, me->tick_size, me->trigger_above_market)) { me->child_order_time = bts::Timer::now(); me->order_placed = true; LOG(OrderMan, Info, "TriggerOrder::_analyze_trigger_and_shoot" "key:{} state:{} " "trigger_above_md:{} trigger_price:{} md:{} " "order_price:{} order_qty:{}", key(), _state, me->trigger_above_market, trigger_price, obs_md->price(), _child_order_price(), me->state.quantity()); me->child_order.activate(Price(_child_order_price()), Quantity(me->state.quantity())); _switch_state(State::WAITING_FOR_FIRST_ACK); } } } void TriggerOrder::_analyze_trigger_and_cancel() { if (me->timeout_exit) { int64_t time_diff = ms_diff(bts::Timer::now(), me->child_order_time); if (time_diff > me->timeout_msecs) { LOG(OrderMan, Info, "TriggerOrder::_analyze_trigger_and_cancel " "key:{} state:{} msecs:{} " "time out, cancelling order", key(), _state, time_diff); _cancel_order(CancelMode::trigger); return; } } if (me->price_cond_exit) { double trigger_price = _trigger_price(); const md::PriceSize *obs_md = _observed_market(); if (!_trigger_met(obs_md, trigger_price, me->tick_size, me->trigger_above_market)) { LOG(OrderMan, Info, "TriggerOrder::_analyze_trigger_and_cancel" "key:{} state:{} " "price condition untrue, cancelling order" "trigger_above_md:{} trigger_price:{} md:{} ", key(), _state, me->trigger_above_market, trigger_price, obs_md->price()); _cancel_order(CancelMode::trigger); return; } } } api::orderman::OrderStatus TriggerOrder::_status() const { switch (_state) { // will only be called once the order // has been activated case State::START: case State::WAITING_FOR_TRIGGER: case State::WAITING_FOR_FIRST_ACK: case State::STEADY: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; case State::END: if (!me->is_succ_inited) return api::orderman::OrderStatus::ORDER_STATUS_ERROR; else { if (me->order_placed) { if (!SpreaderUtils::order_in_terminal_state( me->child_state.status())) return api::orderman::OrderStatus::ORDER_STATUS_WORKING; else { if (SpreaderUtils::order_in_error_state( me->child_state.status())) return api::orderman::OrderStatus::ORDER_STATUS_ERROR; else if (SpreaderUtils::order_in_completed_state( me->child_state.status())) return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; else if (SpreaderUtils::order_in_cancelled_state( me->child_state.status())) { switch (me->cancel_mode) { case CancelMode::none: // this means an unscolicted child cxl case CancelMode::external: return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; case CancelMode::trigger: return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; } } } } else return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; } } bts_assert(false); return api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; } void TriggerOrder::_compute_state() { if (!me->is_recovered) { me->state.set_status(_status()); me->state.set_filled_quantity(me->child_state.filled_quantity()); me->state.set_last_price(me->child_state.last_price()); me->state.set_avg_price(me->child_state.avg_price()); if (_state == State::STEADY) me->state.set_display_status(bts::api::orderman::OrderState::HIDDEN); else me->state.set_display_status(bts::api::orderman::OrderState::VISIBLE); } } void TriggerOrder::_observe_market_once() { if (!me->market_observed_once) { const md::PriceSize *obs_md = _observed_market(); if (obs_md != nullptr && obs_md->size() > 0) { me->market_observed_once = true; me->trigger_above_market = _trigger_price() >= obs_md->price(); LOG(OrderMan, Info, "TriggerOrder::_observe_market_once " "key:{} state:{} " "md_p:{} md_q:{} trigger_above_md:{}", key(), _state, obs_md->price(), obs_md->size(), me->trigger_above_market); } } } const md::PriceSize *TriggerOrder::_observed_market() const { if (me->order_def.custom_def().trigger().trigger_condition().price_type() == api::orderman::TriggerPriceType::BID) { const auto &rv = me->book.bid()[0]; return &rv; } else if (me->order_def.custom_def() .trigger() .trigger_condition() .price_type() == api::orderman::TriggerPriceType::ASK) { const auto &rv = me->book.ask()[0]; return &rv; } else { bts_assert(false); return nullptr; } } double TriggerOrder::_trigger_price() const { return me->state.price(); } double TriggerOrder::_child_order_price() const { const auto &trigger_action = me->order_def.custom_def().trigger().trigger_action(); double rv = bts::os::nan(); if (trigger_action.has_payup()) { double offset = trigger_action.payup().payup_ticks() * me->tick_size; if (me->order_def.side() == api::Side::SIDE_BUY) rv = _trigger_price() + offset; else rv = _trigger_price() - offset; } else rv = trigger_action.price(); rv = bts::securities::raw_round_to_quote_price(rv, me->tick_size, me->order_def.side()); return rv; } void TriggerOrder::_cancel_order(CancelMode cancel_mode) { me->cancel_mode = cancel_mode; me->child_order.cancel(); LOG(OrderMan, Info, "TriggerOrder::_cancel_order key:{} state:{} mode:{}", key(), _state, cancel_mode); _switch_state(State::END); } bool TriggerOrder::_activated() const { return me->services != nullptr; } bool TriggerOrder::_gr_than_eq(double p1, double p2, double tick_size) { return bts::securities::test_price_equality(p1, p2, tick_size) || p1 >= p2; } bool TriggerOrder::_trigger_met(const md::PriceSize *obs_md, double trpr, double tick_size, bool trigger_above_md) { if (obs_md != nullptr) return (trigger_above_md && _gr_than_eq(obs_md->price(), trpr, tick_size)) || (!trigger_above_md && _gr_than_eq(trpr, obs_md->price(), tick_size)); return false; } } // namespace orderman } // namespace bts