Some name changes and cleanup

This commit is contained in:
Taha Afzal committed 2023-03-20 10:23:21 -04:00
1 parent 6612a6d7e1
commit fa22cbd386
7 files changed
+171 -51

No files matched your search

@@ -13,6 +13,7 @@
#include "lib/os/os.h"
#include "lib/tracing/bts_trace.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/helper_macros.h"
namespace bts {
@@ -64,8 +65,8 @@ OrderOpResult SpreaderOrder::on_activate(
Price price, Quantity quantity, OrderServices &services) {
if (!_active)
return OrderOpResult{api::orderman::ORDER_ERROR_OP_NOT_SUPPORTED};
quantity = _bookkeeping_data().fqty_helper().transform_incoming_spreader_qty(
quantity);
quantity =
_bookkeeping_data().fqty_helper().in_transform_spreader_qty(quantity);
SpreaderOrderServices spreader_order_services(&services);
_on_activate(price, quantity, spreader_order_services);
// the reason why this is immediatly reported (vs in the timer
@@ -78,8 +79,8 @@ OrderOpResult SpreaderOrder::on_activate(
OrderOpResult SpreaderOrder::on_update(Price price, Quantity quantity) {
if (!_active)
return OrderOpResult{api::orderman::ORDER_ERROR_OP_NOT_SUPPORTED};
quantity = _bookkeeping_data().fqty_helper().transform_incoming_spreader_qty(
quantity);
quantity =
_bookkeeping_data().fqty_helper().in_transform_spreader_qty(quantity);
LOG(OrderMan, Info, "SpreaderOrder.on_update key:{} price:{} quantity:{}",
key().value(), price.value(), quantity.value());
_state_worker->on_update(price, quantity);
@@ -152,7 +153,7 @@ void SpreaderOrder::_on_book_update(const BookUpdateEvent &book_event) {
auto scoped = _order_services->log_scope(
"SpreaderOrder::_on_book_update", key().value());
const Book &book =
_bookkeeping_data().fqty_helper().transform_book(book_event.book);
_bookkeeping_data().fqty_helper().in_transform_book(book_event.book);
_state_worker->on_book(book);
}
void SpreaderOrder::_on_settlement_update(
@@ -197,8 +198,12 @@ void SpreaderOrder::_keep_hedging_path_hot() {
void SpreaderOrder::_on_child_order_update(
const OrderStateUpdateEvent &ord_ev_arg) {
SpreaderLegData *leg =
_bookkeeping_data().find_leg_from_orderkey(ord_ev_arg.key);
bts_assert(leg != nullptr);
const OrderStateUpdateEvent &ord_ev =
_bookkeeping_data().fqty_helper().transform_order_event(ord_ev_arg);
_bookkeeping_data().fqty_helper().in_transform_order_event(
leg->leg_property_data().leg_security_key(), ord_ev_arg);
_perf_ts = utils::TimeStamp::now();
auto start = _perf_ts;
bool order_acked = SpreaderUtils::order_acknowledged(ord_ev.status);
@@ -312,8 +317,8 @@ void SpreaderOrder::_on_activate(
Price price, Quantity quantity, SpreaderOrderServices &order_services) {
bts_assert(_inited());
bts_assert(!_activated());
quantity = _bookkeeping_data().fqty_helper().transform_incoming_spreader_qty(
quantity);
quantity =
_bookkeeping_data().fqty_helper().in_transform_spreader_qty(quantity);
LOG(OrderMan, Info, "SpreaderOrder.on_activate key:{} price:{} quantity:{}",
key().value(), price.value(), quantity.value());
_order_services = new SpreaderOrderServices(order_services);
@@ -482,7 +487,7 @@ void SpreaderOrder::_comp_and_report_state() {
key(), status, reported_state.price(), reported_state.quantity(),
reported_state.filled_quantity(), reported_state.avg_price());
const auto &rerported_state_adj =
_bookkeeping_data().fqty_helper().transform_outgoing_order_state(
_bookkeeping_data().fqty_helper().out_transform_order_state(
reported_state);
_order_services->report_state(rerported_state_adj);
}
@@ -153,7 +153,7 @@ class SpreaderOrder : public Order, public ISpreaderManager {
SecurityKey sec_key,
bool) override {
auto qty_adjusted =
_bookkeeping_data().fqty_helper().transform_outgoing_leg_qty(
_bookkeeping_data().fqty_helper().out_transform_leg_order_qty(
sec_key, quantity);
child_order.activate(price, qty_adjusted);
}
@@ -164,7 +164,7 @@ class SpreaderOrder : public Order, public ISpreaderManager {
SecurityKey sec_key,
bool) override {
auto qty_adjusted =
_bookkeeping_data().fqty_helper().transform_outgoing_leg_qty(
_bookkeeping_data().fqty_helper().out_transform_leg_order_qty(
sec_key, quantity);
child_order.update(price, qty_adjusted);
}
@@ -67,6 +67,9 @@ class LegPropertyData {
uint32_t n_queue_holder_orders() const {
return _leg_params.quote_params().n_queue_holder_orders();
}
const bts::api::ContractLeg& leg () const{
return _leg_contract;
}
};
} // namespace orderman
@@ -8,15 +8,6 @@ namespace orderman {
using namespace bts::api::orderman;
std::vector<LegPropertyData> adjust_for_fr_qty_legs(
const std::vector<LegPropertyData> &legs) {
std::vector<LegPropertyData> rv;
for (const auto &l : legs) {
rv.push_back(SpreaderFractionalQtyHelper::transform_leg(l));
}
return rv;
}
SpreaderBookkeepingData::SpreaderBookkeepingData(
ISpreaderManager &spreader_manager,
bts::orderman::OrderKey spreader_order_key,
@@ -34,7 +25,7 @@ SpreaderBookkeepingData::SpreaderBookkeepingData(
.spreader()
.execution_strategy()
.hedge_pricing()),
_fqty_helper(adjust_for_fr_qty_legs(legs)) {
_fqty_helper(spreader_order_key, legs) {
LOG(OrderMan, Info,
"SpreaderBookkeepingData.cons started "
"key: {} n_legs: {}",
@@ -114,6 +114,18 @@ class SpreaderBookkeepingData {
}
return nullptr;
}
SpreaderLegData *find_leg_from_orderkey(bts::orderman::OrderKey order_key) {
for (SpreaderLegData &leg : _leg_data)
if (leg.leg_property_data().is_active_quoting())
if (leg.key() == order_key)
return &leg;
for (SpreaderLegData &leg : _leg_data) {
SingleFillHedger *rv = leg.find_hedger_from_orderkey(order_key);
if (rv != nullptr)
return &leg;
}
return nullptr;
}
// creates a new hedger for a given leg index,
// adds it to appropriate place in _hedgers,
// and returns a ref to it
@@ -1,17 +1,44 @@
#include "SpreaderFractionalQtyHelper.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/PriceSize.h"
#include "lib/orderman/events/BookUpdateEvent.h"
#include "lib/orderman/events/OrderStateUpdateEvent.h"
#include "lib/orderman/orders/spreader_orders/spreader/LegPropertyData.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/bts_assert.h"
#include <bits/stdint-uintn.h>
#include <utility>
namespace bts::orderman {
// TODO: get it from config
double get_qty_tick(const api::Security &sec) {
// only Deribit options have fractional qtys
if (sec.has_deribit()) {
if (sec.has_option()) {
if (sec.symbol() == "BTC") {
return 0.1;
}
}
}
return 1.0;
}
double get_leg_qty_mult(const api::Security &sec) {
double tick_size = get_qty_tick(sec);
return 1.0 / tick_size;
}
struct SFQHLegData {
const SecurityKey key;
const double qty_mult;
const bool passthrough = true;
SFQHLegData(SecurityKey key, double qty_mult)
: key(key), qty_mult(qty_mult),
passthrough(Quantity::equal_d(qty_mult, 1.0)) {}
};
SFQHLegData const *find_sec(
@@ -29,15 +56,53 @@ struct SpreaderFractionalQtyHelper ::PImpl {
std::vector<SFQHLegData> leg_mults;
OrderStateUpdateEvent op_ord = {};
bool passthrough = false;
PImpl(const std::vector<LegPropertyData> &legs) : leg_pds(legs) {}
PImpl() {}
};
// std::vector<LegPropertyData> SpreaderFractionalQtyHelper::transform_legs(
// const std::vector<LegPropertyData> &lpd_vec) {
// std::vector<LegPropertyData> rv = {};
// for (const auto &lpd : lpd_vec) {
// double leg_tick_size = get_qty_tick(lpd.security());
// double leg_mult = get_leg_qty_mult(lpd.security());
// bts::api::ContractLeg leg_adj = lpd.leg_contract();
// leg_adj.set_quantity(lpd.size_multiplier() * leg_mult);
// rv.emplace_back(
// lpd.leg_index(), leg_adj, lpd.leg_params(), lpd.trading_side(),
// api::SyntheticContract::PriceCalc::
// SyntheticContract_PriceCalc_PRICECALC_STANDARD,
// leg_tick_size);
// }
// return rv;
// }
SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper(
const std::vector<LegPropertyData> &lpd_vec)
: me(new PImpl(lpd_vec)) {
for (const auto &l : lpd_vec) {
double mult = 1.0 / l.qty_tick_size();
me->leg_mults.push_back({SecurityKey(l.security().id()), mult});
OrderKey spreader_ord_key, const std::vector<LegPropertyData> &lpd_vec)
: me(new PImpl()) {
for (const auto &lpd : lpd_vec) {
double leg_tick_sz = get_qty_tick(lpd.security());
double leg_mult = get_leg_qty_mult(lpd.security());
bts::api::ContractLeg leg_adj = lpd.leg_contract();
leg_adj.set_quantity(lpd.size_multiplier() * leg_mult);
me->leg_pds.emplace_back(
lpd.leg_index(), leg_adj, lpd.leg_params(), lpd.trading_side(),
api::SyntheticContract::PriceCalc::
SyntheticContract_PriceCalc_PRICECALC_STANDARD,
leg_tick_sz);
me->leg_mults.push_back({SecurityKey(lpd.security().id()), leg_mult});
}
me->passthrough = true;
size_t i = 0;
for (const auto &lm : me->leg_mults) {
me->passthrough &= lm.passthrough;
const auto &lpd = me->leg_pds.at(i++);
LOG(OrderMan, Info,
"SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper key: {} "
"leg_sec: {} "
"mult: {} passthrough: {} leg_contract: {} params: {}",
spreader_ord_key.value(), lm.key.value(), lm.qty_mult, lm.passthrough,
utils::pb::to_string(lpd.leg()),
utils::pb::to_string(lpd.leg_params()));
}
}
@@ -45,41 +110,82 @@ const std::vector<LegPropertyData> &SpreaderFractionalQtyHelper::legs() const {
return me->leg_pds;
}
LegPropertyData SpreaderFractionalQtyHelper::transform_leg(
const LegPropertyData &lpd) {
LegPropertyData rv = lpd;
return rv;
}
const Book &SpreaderFractionalQtyHelper::transform_book(const Book &bk) {
const Book &SpreaderFractionalQtyHelper::in_transform_book(const Book &bk) {
if (me->passthrough)
return bk;
SFQHLegData const *lp = find_sec(bk.security_key(), me->leg_mults);
bts_assert(lp != nullptr);
if (lp->passthrough)
return bk;
me->op_book = bk;
double qm = lp->qty_mult;
for (auto &ps : me->op_book.bid()) {
ps = bts::md::PriceSize(ps.int_price(), ps.size() * qm);
}
for (auto &ps : me->op_book.ask()) {
ps = bts::md::PriceSize(ps.int_price(), ps.size() * qm);
}
// mult by leg_mult
return me->op_book;
}
const OrderStateUpdateEvent &SpreaderFractionalQtyHelper::transform_order_event(
const OrderStateUpdateEvent &ev) {
if (me->passthrough)
const OrderStateUpdateEvent &
SpreaderFractionalQtyHelper::in_transform_order_event(
SecurityKey sec_key, const OrderStateUpdateEvent &ev) {
auto log_ev = [](auto sec_key, const auto &ev, const auto &rv_ev) {
LOG(OrderMan, Info,
"SpreaderFractionalQtyHelper::in_transform_order_event sec_key: {} "
"ev.qty: {} ev.filled_qty: {} rv.qty: {} rv.filled_qty: {}",
sec_key.value(), ev.quantity, ev.filled_quantity, rv_ev.quantity,
rv_ev.filled_quantity);
};
if (me->passthrough) {
log_ev(sec_key, ev, ev);
return ev;
}
SFQHLegData const *lp = find_sec(sec_key, me->leg_mults);
bts_assert(lp != nullptr);
if (lp->passthrough) {
log_ev(sec_key, ev, ev);
return ev;
}
me->op_ord = ev;
double qmult = lp->qty_mult;
me->op_ord.quantity *= qmult;
me->op_ord.filled_quantity *= qmult;
me->op_ord.filled_at_attach_time_quantity *= qmult;
log_ev(sec_key, ev, me->op_ord);
return me->op_ord;
}
Quantity SpreaderFractionalQtyHelper::transform_incoming_spreader_qty(
Quantity SpreaderFractionalQtyHelper::in_transform_spreader_qty(
Quantity qty) const {
if (me->passthrough)
return qty;
return qty;
}
Quantity SpreaderFractionalQtyHelper::transform_outgoing_leg_qty(
SecurityKey, Quantity qty) const {
if (me->passthrough)
return qty;
return qty;
Quantity SpreaderFractionalQtyHelper::out_transform_leg_order_qty(
SecurityKey sec_key, Quantity qty) const {
auto tr = [&]() {
if (me->passthrough)
return qty;
SFQHLegData const *lp = find_sec(sec_key, me->leg_mults);
bts_assert(lp != nullptr);
if (lp->passthrough)
return qty;
return Quantity::create_new(qty.full_value() / lp->qty_mult);
};
auto rv_qty = tr();
LOG(OrderMan, Info,
"SpreaderFractionalQtyHelper::out_transform_leg_order_qty qty: {} "
"rv_qty: {}",
qty.full_value(), rv_qty.full_value());
return rv_qty;
}
const bts::api::orderman::OrderState &
SpreaderFractionalQtyHelper::transform_outgoing_order_state(
SpreaderFractionalQtyHelper::out_transform_order_state(
bts::api::orderman::OrderState &ord_st) {
if (me->passthrough)
return ord_st;
@@ -1,6 +1,7 @@
#pragma once
#include "lib/domain_model/common.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orders/spreader_orders/spreader/LegPropertyData.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderLegData.h"
@@ -13,15 +14,17 @@ class Book;
class OrderStateUpdateEvent;
class SpreaderFractionalQtyHelper {
public:
static LegPropertyData transform_leg(const LegPropertyData &);
SpreaderFractionalQtyHelper(const std::vector<LegPropertyData> &legs);
// static std::vector<LegPropertyData> transform_legs(
// const std::vector<LegPropertyData> &lpd_vec);
SpreaderFractionalQtyHelper(
OrderKey spreader_ord_key, const std::vector<LegPropertyData> &legs);
const std::vector<LegPropertyData> &legs() const;
const Book &transform_book(const Book &book);
const OrderStateUpdateEvent &transform_order_event(
const OrderStateUpdateEvent &);
Quantity transform_incoming_spreader_qty(Quantity qty) const;
Quantity transform_outgoing_leg_qty(SecurityKey key, Quantity qty) const;
const bts::api::orderman::OrderState &transform_outgoing_order_state(
const Book &in_transform_book(const Book &book);
const OrderStateUpdateEvent &in_transform_order_event(
SecurityKey sec_key, const OrderStateUpdateEvent &);
Quantity in_transform_spreader_qty(Quantity qty) const;
Quantity out_transform_leg_order_qty(SecurityKey key, Quantity qty) const;
const bts::api::orderman::OrderState &out_transform_order_state(
bts::api::orderman::OrderState &);
private: