Files
spark/src/lib/orderman/orders/book_algos/OCOOrder.cpp
T

242 lines
7.7 KiB
C++

#include "OCOOrder.h"
#include "lib/orderman/OrderBuilder.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/helper_macros.h"
#include <google/protobuf/timestamp.pb.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
struct OCOOrder::PImpl {
PImpl() {}
int other_ticks;
bts::api::RelativeSide other_side;
OrderDefinition other_def;
bool hedge_sent;
};
OCOOrder::OCOOrder() : me(new PImpl()) {}
OCOOrder::~OCOOrder() {}
void OCOOrder::setup_child(
const api::orderman::OrderDefinition &this_def,
const PreActivationOrderServices &,
api::orderman::OrderState &initial_state,
api::orderman::OrderDefinition *out_child) {
initial_state.mutable_oco();
auto const &oco_def = this_def.custom_def().oco();
*out_child->mutable_custom_def() = oco_def.child();
me->other_ticks = oco_def.other_ticks();
me->other_side = oco_def.other_side();
me->hedge_sent = false;
}
// hedge here means 'other'
bool OCOOrder::setup_hedge(
const api::orderman::OrderDefinition &this_def,
const PreActivationOrderServices &,
api::orderman::OrderDefinition *out_hedge) {
auto const &oco_def = this_def.custom_def().oco();
if (oco_def.has_other()) {
*out_hedge->mutable_custom_def() = oco_def.other();
bts_assert_msg(
me->other_side != api::RELATIVESIDE_UNDEFINED,
"undefined relativeside");
if (oco_def.other_side() == api::RELATIVESIDE_BUY)
out_hedge->set_side(api::SIDE_BUY);
else if (oco_def.other_side() == api::RELATIVESIDE_SELL)
out_hedge->set_side(api::SIDE_SELL);
else if (oco_def.other_side() == api::RELATIVESIDE_SAME)
out_hedge->set_side(definition().side());
else if (oco_def.other_side() == api::RELATIVESIDE_OPPOSITE) {
if (definition().side() == api::SIDE_BUY)
out_hedge->set_side(api::SIDE_SELL);
else
out_hedge->set_side(api::SIDE_BUY);
} else
bts_assert_msg(false, "unknown relativeside");
return true;
} else
return false;
}
void OCOOrder::process_child_state_change(
const api::orderman::OrderState &orig_state,
const OrderStateUpdateEvent &new_state) {
uint32_t fill_qty = new_state.filled_quantity - orig_state.filled_quantity();
const auto &the_state = hedges_state();
auto &the_hedges = hedges();
for (const auto &i : the_state) {
const auto &hedge_state = i.second;
uint32_t working_qty =
hedge_state.quantity() - hedge_state.filled_quantity();
uint32_t newqty = working_qty - std::min(fill_qty, working_qty);
bts_assert(newqty <= working_qty);
auto it = the_hedges.find(i.first);
if (it != the_hedges.end()) {
if (newqty != working_qty) {
if (newqty > 0) {
LOG(OrderMan, Info, "OCO reducing hedge qty from {} to {}",
working_qty, newqty);
it->second.update(Price(hedge_state.price()), Quantity(newqty));
} else
it->second.cancel();
} else if (
new_state.status !=
api::orderman::OrderStatus::ORDER_STATUS_PENDING_WORKING &&
new_state.status !=
api::orderman::OrderStatus::ORDER_STATUS_WORKING) {
it->second.cancel();
}
} else {
LOG(OrderMan, Error, "OCO Can't find hedge order {}", i.first);
cancel_child();
}
}
}
void OCOOrder::process_hedge_state_change(
const api::orderman::OrderState &orig_state,
const OrderStateUpdateEvent &new_state) {
uint32_t fill_qty = new_state.filled_quantity - orig_state.filled_quantity();
uint32_t working_qty =
child_state().quantity() - child_state().filled_quantity();
uint32_t newqty = working_qty - std::min(fill_qty, working_qty);
bts_assert(newqty <= working_qty);
if (newqty != working_qty) {
if (newqty > 0) {
LOG(OrderMan, Info, "OCO reducing child qty from {} to {}",
working_qty, newqty);
update_child(Price(child_state().price()), Quantity(newqty));
} else
cancel_child();
} else if (
new_state.status !=
api::orderman::OrderStatus::ORDER_STATUS_PENDING_WORKING &&
new_state.status != api::orderman::OrderStatus::ORDER_STATUS_WORKING) {
cancel_child();
}
}
void OCOOrder::on_book_update(const bts::orderman::BookUpdateEvent &) {
switch (this_state().status()) {
case ORDER_STATUS_WORKING:
switch (child_state().status()) {
case ORDER_STATUS_INACTIVE: {
activate_child(
Price(this_state().price()), Quantity(this_state().quantity()));
if (!me->hedge_sent) {
double prx = this_state().price();
if (definition().side() == api::SIDE_BUY)
prx = prx + tick_size() * me->other_ticks;
else
prx = prx - tick_size() * me->other_ticks;
build_and_send_hedge(Price(prx), Quantity(this_state().quantity()));
me->hedge_sent = true;
}
transition(ORDER_STATUS_WORKING);
report_state();
} break;
case ORDER_STATUS_WORKING: {
} break;
case ORDER_STATUS_PENDING_WORKING:
break;
// child cannot be in any of these states if we are in the working state
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
break;
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
break;
case ORDER_STATUS_INACTIVE:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
}
OrderOpResult OCOOrder::on_cancel() {
LOG(OrderMan, Info, "Canceling OCOOrder Order {}", key().value());
switch (this_state().status()) {
case ORDER_STATUS_WORKING:
switch (child_state().status()) {
case ORDER_STATUS_INACTIVE:
transition(ORDER_STATUS_CANCELED);
break;
case ORDER_STATUS_WORKING:
if (!is_detached()) {
cancel_child();
for (auto &i : hedges())
i.second.cancel();
}
transition(ORDER_STATUS_CANCELED);
break;
case ORDER_STATUS_PENDING_WORKING:
// child is running but it cannot be canceled at this point
transition(this_state().status(), "Cannot cancel order");
break;
// child cannot be in any of these if we are in the working state
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
break;
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
transition(this_state().status(), "Cannot cancel order");
break;
// these are unreacheable for this order type
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
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 OrderOpResult{};
}
} // namespace orderman
} // namespace bts