From 2e51aebc9429acacd1eaccd242199db53befd4fa Mon Sep 17 00:00:00 2001 From: Mohammad Arham Date: Thu, 14 Sep 2023 16:25:59 +0000 Subject: [PATCH] position flattener --- src/lib/config/protos/toggles.proto | 5 +- .../algo_orders/PositionFlattenerAlgo.cpp | 400 ++++++++++++++++++ .../algo/algo_orders/PositionFlattenerAlgo.h | 39 ++ .../algo/algo_orders/RegisterDorman.cpp | 16 +- 4 files changed, 458 insertions(+), 2 deletions(-) create mode 100644 src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.cpp create mode 100644 src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h diff --git a/src/lib/config/protos/toggles.proto b/src/lib/config/protos/toggles.proto index 353066fe9..e775ce0af 100644 --- a/src/lib/config/protos/toggles.proto +++ b/src/lib/config/protos/toggles.proto @@ -66,7 +66,10 @@ message CustomFormatIceSecurities{ message IgnoreNansInDayPnL { optional bool enabled = 1 [default = true]; } - +message SendLimitOrderForPositionFlattener { + optional bool enabled = 1 [default = true]; + optional uint32 quantity = 2 [default = 0]; +} message DynamicAlgos{ optional bool enable_dorman = 1 [default = false]; optional bool enable_pyramid = 2 [default = false]; diff --git a/src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.cpp b/src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.cpp new file mode 100644 index 000000000..af69da36f --- /dev/null +++ b/src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.cpp @@ -0,0 +1,400 @@ +#include "lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h" +#include "lib/api/services/OrderService.pb.h" +#include "lib/config/config.h" +#include "lib/config/protos/toggles.pb.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/IntPrice.h" +#include "lib/md/PriceSize.h" +#include "lib/orderman/actors/SODPosition.h" +#include "lib/orderman/order_factory/IOrderFactory.h" +#include "lib/orderman/orderman_utils/Book.h" +#include "lib/orderman/orderman_utils/orderman_common.h" +#include "lib/orderman/orderman_utils/orderman_utils.h" +#include "lib/orderman/orders/algo/DynamicHelpers.h" +#include "lib/orderman/orders/algo/IAlgoOrder.h" +#include "lib/orderman/orders/algo/IAlgoServices.h" +#include "lib/orderman/orders/algo/algo_orders/MomentumAlgo.h" +#include "lib/os/os.h" +#include "lib/utils/PBUtils.h" +#include "lib/utils/bts_assert.h" +#include "lib/utils/bts_chrono.h" +#include "lib/utils/datetime.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +namespace bts { +namespace orderman { + +using namespace api::orderman; +using namespace google::protobuf; + +enum class PositionFlattenerAlgo::AlgoStatus { + PAUSED, + WORKING, + WAITING_FOR_CXL_ACK, + WAITING_FOR_FLATTEN, + CANCELLED +}; +enum class PositionFlattenerAlgo::ExitPath { CANCEL, ERR, COMPLETE }; +ChildTemplate *_get_Terimnator_child_template(IBeforeLaunchAlgoServices &serv, + const CustomOrderDefinition &cod, + SecurityKey key, api::Side side) { + OrderDefinition rv = serv.definition(); + rv.set_security_key(key.value()); + rv.set_side(side); + rv.mutable_custom_def()->CopyFrom(cod); + return &(serv.make_child_template(rv)); +} +struct PositionFlattenerAlgoLegData { + const SecurityKey sec_key; + ChildTemplate *order_template = nullptr; + OrderKey order_key; + ChildState order_state; + ChildStatus status; + PositionFlattenerAlgoLegData(SecurityKey sec_key_a, + ChildTemplate *order_template_a) + : sec_key(sec_key_a), order_template(order_template_a), + order_key(null_order_key()), order_state(), status() {} +}; +struct PositionFlattenerAlgoParams { + SecurityKey security_key_id; + std::string security_name_str; + std::vector legs; + bool dont_flatten; + PositionFlattenerAlgoParams(SecurityKey key, std::string sec_name, + std::vector lgs, + bool dont_flatten) + : security_key_id(key), security_name_str(sec_name), legs(lgs), + dont_flatten(dont_flatten) {} +}; +struct PositionFlattenerAlgo::PImpl { + IAlgoServices *algo; + std::vector legs; + AlgoStatus status = AlgoStatus::PAUSED; + std::unique_ptr algo_params; + OrderKey flatten_child_key = null_order_key(); + AccountID acc_id; + int order_distance = 0; + // std::unordered_set flatten_child_keys_sim; + ChildTemplate *flatten_template_buy = nullptr; + ChildTemplate *flatten_template_sell = nullptr; + double pos = 0; + bool is_sim; +}; +bool _convert_params(IBeforeLaunchAlgoServices &serv, + const CustomOrderDefinition &cod, + std::unique_ptr &out_p) { + LOG(OrderMan, Diag, "PositionFlattenerAlgo::_convert_params"); + const DynamicOrderDefinition &def = cod.dynamic(); + const auto ¶ms = def.order_params(); + std::vector prs; + auto sec_key = SecurityKey(serv.security().id()); + size_t n_child_ords = 5; + for (size_t i = 0; i < n_child_ords; i++) { + auto idx = std::to_string(i + 1); + auto order = get_if(params, "Order " + idx); + if (!order.has_value()) { + continue; + } + ChildTemplate *child_template = _get_Terimnator_child_template( + serv, order.value(), sec_key, api::Side::SIDE_BUY); + prs.push_back(PositionFlattenerAlgoLegData(sec_key, child_template)); + } + + auto flatten = get_if(params, "Dont Flatten"); + if (!flatten.has_value()) { + return false; + } + out_p = std::make_unique( + PositionFlattenerAlgoParams(sec_key, + serv.security().glbx().security_desc(), prs, + flatten.value())); + + return true; +} +PositionFlattenerAlgo::PositionFlattenerAlgo() : me(new PImpl()) {} +PositionFlattenerAlgo::~PositionFlattenerAlgo() {} +IAlgoServices &PositionFlattenerAlgo::algo() const { return *me->algo; } + +ChildTemplate *_get_limit_template(IBeforeLaunchAlgoServices &serv, + SecurityKey key, api::Side side) { + OrderDefinition rv = serv.definition(); + rv.set_security_key(key.value()); + rv.set_side(side); + rv.mutable_custom_def()->mutable_limit()->MergeFrom( + api::orderman::LimitOrderDefinition()); + return &(serv.make_child_template(rv)); +} +ChildTemplate *_get_market_template(IBeforeLaunchAlgoServices &serv, + SecurityKey key, api::Side side) { + OrderDefinition rv = serv.definition(); + rv.set_security_key(key.value()); + rv.set_side(side); + rv.mutable_custom_def()->mutable_market()->MergeFrom( + api::orderman::MarketOrderDefinition()); + return &(serv.make_child_template(rv)); +} +OrderOpResult +PositionFlattenerAlgo::do_before_launch(IBeforeLaunchAlgoServices &serv) { + LOG(OrderMan, Diag, "PositionFlattenerAlgo::do_before_launch"); + OrderDefinition def = serv.definition(); + + if (def.has_custom_def() && def.custom_def().has_dynamic() && + _convert_params(serv, def.custom_def(), me->algo_params)) { + me->acc_id = AccountID(def.account_id()); + me->is_sim = + config::get() + .enabled(); + me->order_distance = + config::get() + .quantity(); + me->legs = + std::vector(me->algo_params->legs); + me->flatten_template_buy = + me->is_sim + ? _get_limit_template(serv, SecurityKey(serv.security().id()), + api::Side::SIDE_BUY) + : _get_market_template(serv, SecurityKey(serv.security().id()), + api::Side::SIDE_BUY); + me->flatten_template_sell = + me->is_sim + ? _get_limit_template(serv, SecurityKey(serv.security().id()), + api::Side::SIDE_SELL) + : _get_market_template(serv, SecurityKey(serv.security().id()), + api::Side::SIDE_SELL); + return {}; + } + + return {OrderError::ORDER_ERROR_INVALID_PARAMETER, + std::string("Parameters are not well formed")}; +} +void PositionFlattenerAlgo::on_position(PositionUpdate const &pos) { + if (pos.security->id() != me->algo->security().id() || + pos.account_id != me->acc_id) { + return; //|| pos.account_id != me->algo-> add this + } + me->pos = + double(pos.long_quantity.value()) - double(pos.short_quantity.value()); + LOG(OrderMan, Diag, + "PositionFlattenerAlgo::on_cancel state {}, pos: {}, long: {}, short: " + "{}", + me->status, me->pos, pos.long_quantity.value(), + pos.short_quantity.value()); +} +void PositionFlattenerAlgo::do_launch(IAlgoServices &algo) { + LOG(OrderMan, Diag, "PositionFlattenerAlgo::do_launch"); + me->algo = &algo; + me->status = PositionFlattenerAlgo::AlgoStatus::WORKING; + // LUANCH CHILD ORDERS + me->algo->subscribe_position(); + for (size_t i = 0; i < me->legs.size(); i++) { + me->legs[i].order_key = me->algo->launch_child( + *me->legs[i].order_template, me->algo->price(), bts::Quantity(1)); + } +} + +void PositionFlattenerAlgo::do_launch_attached(IAlgoServices &algo, OrderKey, + ChildState) { + me->algo = &algo; + _cxl_and_end(true, + "PositionFlattener Algo can not be attached to working orders"); +} + +void PositionFlattenerAlgo::do_update(api::orderman::Update const &update) { + if (!update.has_custom() || !update.custom().has_dynamic()) { + return; + } + const DynamicOrderDefinition &def = update.custom().dynamic(); + const auto ¶ms = def.order_params(); + auto dont_flatten = get_if(params, "Dont Flatten"); + if (!dont_flatten.has_value()) { + return; + } + me->algo_params->dont_flatten = dont_flatten.value(); + LOG(OrderMan, Diag, + "PositionFlattenerAlgo order {} receiving update: {} UPDATES NOT " + "ALLOWED", + algo().order_key().value(), utils::pb::to_string(update)); +} +std::optional +find_leg_index(std::vector legs, OrderKey k) { + for (size_t index = 0; index < legs.size(); index++) { + + if (legs[index].order_key == k) { + return index; + } + } + return std::nullopt; +} +void PositionFlattenerAlgo::on_child_change(OrderKey k, + ChildState const &state) { + if (me->flatten_child_key == k) { + // bts_assert(state.status != ChildStatus::CANCELED); + if (state.status == ChildStatus::COMPLETED) { + me->status = PositionFlattenerAlgo::AlgoStatus::PAUSED; + _cxl_and_end(false, "POSITION FLATTENED"); + return; + } + } + auto maybe_leg_index = find_leg_index(me->legs, k); + if (!maybe_leg_index.has_value()) { + return; + } + auto leg_index = maybe_leg_index.value(); + me->legs[leg_index].status = state.status; + switch (me->status) { + case PositionFlattenerAlgo::AlgoStatus::WORKING: + case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN: + break; + case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK: + if (state.status != ChildStatus::WORKING) { + _cxl_and_end(false, ""); + } + break; + case PositionFlattenerAlgo::AlgoStatus::CANCELLED: + case PositionFlattenerAlgo::AlgoStatus::PAUSED: + bts_assert(false); + }; +} +Price get_price(double algo_price, api::Side side, bool is_sim, int quantity, + double tick_val) { + if (!is_sim) { + return Price(algo_price); + } + if (side == api::Side::SIDE_BUY) { + return Price(algo_price + tick_val * std::abs(quantity)); + } + return Price(algo_price - tick_val * std::abs(quantity)); +} +void PositionFlattenerAlgo::_fire_orders(size_t count, api::Side side) { + bts_assert(me->status == + PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN); + LOG(OrderMan, Diag, "PositionFlattenerAlgo::_fire_orders count: {} side: {}", + count, side); + ChildTemplate &ct = side == api::Side::SIDE_BUY ? *me->flatten_template_buy + : *me->flatten_template_sell; + double tick_size = me->algo->security().contract_spec().low_tick(); + auto price = get_price(me->algo->price().value(), side, me->is_sim, + me->order_distance, tick_size); + me->flatten_child_key = + me->algo->launch_child(ct, price, bts::Quantity(count)); + return; +} +// this only gets called on am explicit algo cancel +// from the outside +IAlgoOrder::OnCancelResponse PositionFlattenerAlgo::on_cancel() { + LOG(OrderMan, Diag, + "PositionFlattenerAlgo::" + "on_cancel state {}", + me->status); + // cancel top spread, let + // hedges work, cancel algo + switch (me->status) { + case PositionFlattenerAlgo::AlgoStatus::WORKING: + _cxl_and_end(false, "Algo cancelled"); + break; + case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN: + case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK: + case PositionFlattenerAlgo::AlgoStatus::CANCELLED: + case PositionFlattenerAlgo::AlgoStatus::PAUSED: + break; + }; + return IAlgoOrder::OnCancelResponse::IGNORE; +} +void PositionFlattenerAlgo::_cxl_leg(bool is_error, + const std::string &err_msg) { + LOG(OrderMan, Diag, + "PositionFlattenerAlgo::_" + "cxl_leg legs {}", + me->legs.size()); + if (me->legs.size()) { + switch (me->legs.back().status) { + case ChildStatus::CANCELED: + case ChildStatus::COMPLETED: + me->legs.pop_back(); + _cxl_and_end(is_error, err_msg); + break; + case ChildStatus::WORKING: + me->algo->cancel_child(me->legs.back().order_key); + }; + } +} +void PositionFlattenerAlgo::_flatten_pos() { + LOG(OrderMan, Diag, + "PositionFlattenerAlgo::_" + "flatten_pos state {}", + me->status); + bts_assert(me->status == + PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN); + if (me->algo_params->dont_flatten || me->pos == 0) { + me->status = PositionFlattenerAlgo::AlgoStatus::PAUSED; + return; + } + if (me->pos < 0) { + _fire_orders(abs(me->pos), api::Side::SIDE_BUY); + return; + } + if (me->pos > 0) { + _fire_orders(abs(me->pos), api::Side::SIDE_SELL); + return; + } +} +void PositionFlattenerAlgo::_cxl_and_end(bool is_error, + const std::string &err_msg) { + LOG(OrderMan, Diag, + "PositionFlattenerAlgo::_" + "cxl_and_end state {} " + "legs size {}", + me->status, me->legs.size()); + if (is_error) { + me->algo->cancel(); + } + switch (me->status) { + case PositionFlattenerAlgo::AlgoStatus::WORKING: + me->status = AlgoStatus::WAITING_FOR_CXL_ACK; + _cxl_and_end(is_error, err_msg); + break; + case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_CXL_ACK: + if (me->legs.size()) { + _cxl_leg(is_error, err_msg); + break; + } else { + me->status = AlgoStatus::WAITING_FOR_FLATTEN; + _flatten_pos(); + _cxl_and_end(is_error, err_msg); + break; + } + case PositionFlattenerAlgo::AlgoStatus::WAITING_FOR_FLATTEN: + break; + case PositionFlattenerAlgo::AlgoStatus::CANCELLED: + case PositionFlattenerAlgo::AlgoStatus::PAUSED: + me->algo->cancel(); + }; +} + +} // namespace orderman +} // namespace bts diff --git a/src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h b/src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h new file mode 100644 index 000000000..de75017bc --- /dev/null +++ b/src/lib/orderman/orders/algo/algo_orders/PositionFlattenerAlgo.h @@ -0,0 +1,39 @@ +#pragma once + +#include "lib/orderman/orders/algo/IAlgoOrder.h" + +namespace bts { +namespace orderman { + +// PositionFlattener runs set child algos and flattens state + +class PositionFlattenerAlgo : public IAlgoOrder { + public: + PositionFlattenerAlgo(); + ~PositionFlattenerAlgo(); + + OrderOpResult do_before_launch(IBeforeLaunchAlgoServices &) override; + void do_launch(IAlgoServices &) override; + void do_launch_attached(IAlgoServices &, OrderKey, ChildState) override; + void do_update(api::orderman::Update const &) override; + void on_child_change(OrderKey, ChildState const &) override; + void on_position(PositionUpdate const &) override; + enum class AlgoStatus; + + private: + enum class ExitPath; + struct PImpl; + std::unique_ptr me; + + IAlgoServices &algo() const; + IAlgoOrder::OnCancelResponse on_cancel() override; + void _cxl_leg(bool is_error, const std::string &err_msg); + void init_child_template(IBeforeLaunchAlgoServices &, + api::orderman::CustomOrderDefinition const &); + void _cxl_and_end(bool is_error, const std::string &err_msg); + void _fire_orders(size_t count, api::Side side); + void _flatten_pos(); +}; + +} // namespace orderman +} // namespace bts diff --git a/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp b/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp index da3afdf12..9bc850d3e 100644 --- a/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp +++ b/src/lib/orderman/orders/algo/algo_orders/RegisterDorman.cpp @@ -4,6 +4,7 @@ #include "MomentumAlgo.h" #include "MomentumRecorder.h" #include "OnSignalAlgo.h" +#include "PositionFlattenerAlgo.h" #include "PyramidAlgo.h" #include "TASAlgo.h" #include "TASCounterAlgo.h" @@ -230,7 +231,19 @@ extern "C" void init_limit_cover(bts::SparkServices &srv) { srv.register_dynamic_algo_order( lc_desc, []() { return std::make_unique(); }); } - +extern "C" void init_position_flattener(bts::SparkServices &srv) { + DynamicOrderDescriptor term; + term.set_dynamic_order_type("PositionFlattener"); + size_t n_child_ords = 5; + *term.add_param_desc() = param_bool("Dont Flatten"); + for (size_t i = 0; i < n_child_ords; i++) { + auto idx = std::to_string(i + 1); + *term.add_param_desc() = param_order("Order " + idx); + } + srv.register_dynamic_algo_order(term, []() { + return std::make_unique(); + }); +} extern "C" void init_on_signal_plugin(bts::SparkServices &srv) { DynamicOrderDescriptor on_signal; on_signal.set_dynamic_order_type("OnSignal"); @@ -325,6 +338,7 @@ extern "C" void init_spark_plugin(bts::SparkServices &srv) { init_on_signal_plugin(srv); init_momentum_algo_plugin(srv); init_momentum_recorder_plugin(srv); + init_position_flattener(srv); init_file_runner_plugin(srv); }