Minor changes and ocmments, to allow for fractional qtys

This commit is contained in:
Taha Afzal committed 2025-01-16 20:18:26 +00:00
1 parent edd3f6cbd6
commit 3e2b5976a8
15 files changed
+268 -698

No files matched your search

+15
View File
@@ -55,6 +55,21 @@
"externalConsole": false,
"MIMode": "gdb",
},
{
"name": "spreader tests",
"type": "cppdbg",
"request": "launch",
"program": "/home/bts/spark/build/sparkd-debug-clang/server/sparkd",
"args": [
"test",
"[spreader]"
],
"stopAtEntry": false,
"cwd": "/home/bts/spark/build/sparkd-debug-clang/server",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
},
{
"name": "DataStreamQueryAnalyzer",
"type": "coreclr",
@@ -71,7 +71,7 @@ OrderOpResult SpreaderOrder::on_activate(
_on_activate(price, quantity, spreader_order_services);
// the reason why this is immediatly reported (vs in the timer
// event) is that if this spreader was constructed through
// on_init_recovered, it wont subsribe to the timer event
// on_init_recovered, it wont subscribe to the timer event
// and hence the report wont go out
_comp_and_report_state();
return OrderOpResult{};
@@ -131,6 +131,10 @@ ChildOrder SpreaderOrder::get_new_hedge_order(size_t leg_index) {
IAlternateOrderGateway *SpreaderOrder::alt_order_gateway() {
return _alt_order_gateway;
}
SpreaderFractionalQtyHelper const *SpreaderOrder::spreader_qty_helper() {
return &_bookkeeping_data().fqty_helper();
}
// events from orders system ////////////////////
/////////////////////////////////////////////////
void SpreaderOrder::_on_time(const bts::mercury::TimerEvent &t_event) {
@@ -196,6 +200,7 @@ void SpreaderOrder::_keep_hedging_path_hot() {
_cw_helper.unset_forced_flag();
}
// all external order acks (quoting or hedging for any leg) end up here
void SpreaderOrder::_on_child_order_update(
const OrderStateUpdateEvent &ord_ev_arg) {
SpreaderLegData *leg =
@@ -486,9 +491,9 @@ void SpreaderOrder::_comp_and_report_state() {
"price:{} qty:{} filled:{} avg_price:{}",
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().out_transform_order_state(
reported_state);
auto rerported_state_adj = reported_state;
_bookkeeping_data().fqty_helper().out_transform_order_state(
rerported_state_adj);
_order_services->report_state(rerported_state_adj);
}
}
@@ -6,6 +6,7 @@
#include "lib/mercury/events/TimerEvent.h"
#include "lib/orderman/events/BookUpdateEvent.h"
#include "lib/orderman/events/OrderStateUpdateEvent.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orders/Order.h"
#include "lib/orderman/orders/spreader_orders/spreader/ISpreaderManager.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h"
@@ -143,30 +144,33 @@ class SpreaderOrder : public Order, public ISpreaderManager {
void setup_new_quoter_order(size_t leg_index) override;
ChildOrder get_new_hedge_order(size_t leg_index) override;
IAlternateOrderGateway *alt_order_gateway() override;
SpreaderFractionalQtyHelper const *spreader_qty_helper() override;
inline bool in_cache_warming_cycle() const override {
return _cw_helper.in_cache_warming_cycle;
}
// this is called by the SpreaderChildOrderState
void place_order(
ChildOrder &child_order,
Price price,
Quantity quantity,
SecurityKey sec_key,
SecurityKey,
bool) override {
auto qty_adjusted =
_bookkeeping_data().fqty_helper().out_transform_leg_order_qty(
sec_key, quantity);
child_order.activate(price, qty_adjusted);
// this is
// auto qty_adjusted =
// _bookkeeping_data().fqty_helper().out_transform_leg_order_qty(
// sec_key, quantity);
child_order.activate(price, quantity);
}
void update_order(
ChildOrder &child_order,
Price price,
Quantity quantity,
SecurityKey sec_key,
SecurityKey,
bool) override {
auto qty_adjusted =
_bookkeeping_data().fqty_helper().out_transform_leg_order_qty(
sec_key, quantity);
child_order.update(price, qty_adjusted);
// auto qty_adjusted =
// _bookkeeping_data().fqty_helper().out_transform_leg_order_qty(
// sec_key, quantity);
child_order.update(price, quantity);
}
private:
@@ -370,8 +374,11 @@ class SpreaderOrder : public Order, public ISpreaderManager {
Quantity total_filled_qty,
Price avg_price) {
bts::api::orderman::OrderState order_state;
bts::orderman::set_quantity(
order_state, StateQuantityType::FilledQuantity,
total_filled_qty.full_value());
order_state.set_status(status);
order_state.set_filled_quantity(total_filled_qty.value());
//order_state.set_filled_quantity(total_filled_qty.value());
order_state.set_last_price(avg_price.value());
order_state.set_price(avg_price.value());
OrderStateUpdateEvent ord_ev(order_key, OrderKey(0), def(), order_state);
@@ -1,9 +1,9 @@
#pragma once
#include "SpreaderFractionalQtyHelper.h"
#include "lib/domain_model/SecurityKey.h"
#include "lib/domain_model/common.h"
#include "lib/orderman/ChildOrder.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orders/book_algos/PricerOrder.h"
namespace bts {
namespace orderman {
@@ -35,6 +35,7 @@ class ISpreaderManager {
// this is used to direct orders coming out of the spreader.
// if this is non null, the orders are routed using this interface
virtual IAlternateOrderGateway *alt_order_gateway() = 0;
virtual SpreaderFractionalQtyHelper const *spreader_qty_helper() = 0;
// the spreader can be in a cache warming cycle and generate
// fake updates, the quoters and hedgers should ignore them
// (however do as much as they can to keep the instruction
@@ -175,6 +175,7 @@ class SingleLegQuoter {
_child_order_state.place_order(price, quantity, _spreader.current_time());
}
void _modify_order(Price price, Quantity quantity) {
_child_order_state.modify_order(price, quantity);
}
void _cancel_order() { _child_order_state.cancel_order(); }
@@ -32,7 +32,8 @@ SpreaderBookkeepingData::SpreaderBookkeepingData(
spreader_order_key.value(), _n_legs);
_leg_data.reserve(_n_legs);
size_t i = 0;
for (const auto &leg_property_data : _fqty_helper.legs()) {
auto transformed_legs = _fqty_helper.get_transformed_legs(legs);
for (const auto &leg_property_data : transformed_legs) {
_leg_data.emplace_back(
spreader_pao_services, spreader_order_key, _n_legs, spreader_manager,
quoter_ord_defs[i], hedger_ord_defs[i], leg_property_data);
@@ -157,6 +157,9 @@ class SpreaderBookkeepingData {
}
size_t n_quoting_legs() const { return _n_quoting_legs; }
SpreaderFractionalQtyHelper &fqty_helper() { return _fqty_helper; }
// SpreaderFractionalQtyHelper const *spreader_qty_helper() {
// return &_fqty_helper;
// }
};
} // namespace orderman
} // namespace bts
@@ -3,6 +3,7 @@
#include "SpreaderUtils.h"
#include "external_interfacing/IAlternateOrderGateway.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/common.h"
#include "lib/orderman/events/OrderStateUpdateEvent.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orders/spreader_orders/spreader/ISpreaderManager.h"
@@ -158,21 +159,25 @@ class SpreaderChildOrderState {
_order_place_time = curr_time;
bts_assert(_n_place_orders == 0);
_n_place_orders++;
auto const *qty_helper = _spreader_manager->spreader_qty_helper();
auto adj_qty =
qty_helper->out_transform_leg_order_qty(_sec_key, quantity);
if (_is_live) {
if (_spreader_manager != nullptr)
_spreader_manager->place_order(
_child_order, price, quantity, _sec_key, _is_quoting);
_child_order, price, adj_qty, _sec_key, _is_quoting);
else
_child_order.activate(price, quantity);
_child_order.activate(price, adj_qty);
} else if (_alt_order_gwy != nullptr)
_alt_order_gwy->place_order(
_sec_key, _test_only_order_key, _side, price, quantity);
_is_quoting, _sec_key, _test_only_order_key, _side, price,
adj_qty);
LOG(OrderMan, Info,
"SpreaderChildOrderState::place_order "
"is_quoting:{} key:{} sec_key:{} live:{} "
"price:{} qty:{} t:{}",
"is_quoting: {} key: {} sec_key: {} live: {} "
"price: {} qty: {} adj_qty:{} t:{}",
_is_quoting, order_key(), _sec_key, _is_live, price, quantity,
(utils::TimeStamp::now() - start).nanoseconds());
adj_qty, (utils::TimeStamp::now() - start).nanoseconds());
}
void modify_order(Price price) { modify_order(price, _out_quantity); }
void modify_order(Price price, Quantity quantity) {
@@ -180,21 +185,25 @@ class SpreaderChildOrderState {
_out_price = price;
_out_quantity = quantity;
_n_modify_orders++;
auto const *qty_helper = _spreader_manager->spreader_qty_helper();
auto adj_qty =
qty_helper->out_transform_leg_order_qty(_sec_key, quantity);
if (_is_live) {
if (_spreader_manager != nullptr) {
_spreader_manager->update_order(
_child_order, price, quantity, _sec_key, _is_quoting);
_child_order, price, adj_qty, _sec_key, _is_quoting);
} else {
_child_order.update(price, quantity);
_child_order.update(price, adj_qty);
}
} else if (_alt_order_gwy != nullptr)
_alt_order_gwy->modify_order(_test_only_order_key, price, quantity);
_alt_order_gwy->modify_order(_test_only_order_key, price, adj_qty);
LOG(OrderMan, Info,
"SpreaderChildOrderState::modify_order "
"is_quoting:{} key:{} sec_key:{} live:{} "
"price:{} quantity:{} mod_no:{} t:{}",
"is_quoting: {} key: {} sec_key: {} live: {} "
"price: {} quantity: {} ady_qty: {} mod_no:{} t:{}",
_is_quoting, order_key(), _sec_key, _is_live, price, quantity,
_n_modify_orders, (utils::TimeStamp::now() - start).nanoseconds());
adj_qty, _n_modify_orders,
(utils::TimeStamp::now() - start).nanoseconds());
}
void cancel_order() {
bts_assert(_n_cancel_orders == 0);
@@ -14,117 +14,60 @@
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;
}
}
} else if (
sec.has_spot() && sec.exchange() == ::bts::api::Venue::VENUE_BINANCE) {
return 0.001;
} else if (
sec.has_spot() && sec.exchange() == ::bts::api::Venue::VENUE_OKX) {
return 0.001;
}
return 1.0;
bool is_crypto_leg(const LegPropertyData &l) {
// TODO
auto v = l.security().exchange();
return v == api::VENUE_BINANCE || v == api::VENUE_BINANCE_USDS_FUTURES ||
v == api::VENUE_BINANCE_COIN_FUTURES ||
v == api::Venue::VENUE_BINANCE_US || v == api::VENUE_DERIBIT ||
v == api::Venue::VENUE_DERIBIT || v == api::Venue::VENUE_OKX;
}
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(
SecurityKey key, const std::vector<SFQHLegData> &leg_vec) {
for (const auto &p : leg_vec) {
if (p.key == key)
return &p;
bool has_crypto_leg(const std::vector<LegPropertyData> &legs) {
for (const auto &l : legs) {
if (is_crypto_leg(l))
return true;
}
return nullptr;
return false;
}
struct SpreaderFractionalQtyHelper ::PImpl {
Book op_book = {};
std::vector<LegPropertyData> leg_pds;
std::vector<SFQHLegData> leg_mults;
OrderStateUpdateEvent op_ord = {};
bool passthrough = false;
PImpl() {}
const bool passthrough = false;
const double in_qty_mult = 1000; // get it from config
PImpl(const std::vector<LegPropertyData> &lpd_vec)
: passthrough(has_crypto_leg(lpd_vec) ? false : true),
in_qty_mult(has_crypto_leg(lpd_vec) ? 1000.0 : 1.0) {}
};
// 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(), lpconstd.trading_side(),
// api::SyntheticContract::PriceCalc::
// SyntheticContract_PriceCalc_PRICECALC_STANDARD,
// leg_tick_size);
// }
// return rv;
// }
std::vector<LegPropertyData> SpreaderFractionalQtyHelper::get_transformed_legs(
const std::vector<LegPropertyData> &legs) const {
std::vector<LegPropertyData> rv = {};
for (const auto &l : legs) {
bts::api::ContractLeg leg_adj = l.leg_contract();
leg_adj.set_quantity(l.size_multiplier() * me->in_qty_mult);
double qty_tick_size = 1.0 / me->in_qty_mult;
LegPropertyData lpd_adj(
l.leg_index(), leg_adj, l.leg_params(), l.trading_side(),
bts::api::SyntheticContract::PriceCalc::
SyntheticContract_PriceCalc_PRICECALC_STANDARD,
qty_tick_size);
rv.push_back(lpd_adj);
}
return rv;
}
SpreaderFractionalQtyHelper::SpreaderFractionalQtyHelper(
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()));
// }
}
: me(new PImpl(lpd_vec)) {}
const std::vector<LegPropertyData> &SpreaderFractionalQtyHelper::legs() const {
return me->leg_pds;
}
const Book &SpreaderFractionalQtyHelper::in_transform_book(const Book &bk) {
const Book &SpreaderFractionalQtyHelper::in_transform_book(
const Book &bk) const {
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;
double qm = me->in_qty_mult;
for (auto &ps : me->op_book.bid()) {
ps = bts::md::PriceSize(ps.int_price(), ps.size() * qm);
}
@@ -137,7 +80,7 @@ const Book &SpreaderFractionalQtyHelper::in_transform_book(const Book &bk) {
const OrderStateUpdateEvent &
SpreaderFractionalQtyHelper::in_transform_order_event(
SecurityKey sec_key, const OrderStateUpdateEvent &ev) {
SecurityKey sec_key, const OrderStateUpdateEvent &ev) const {
auto log_ev = [](auto sec_key, const auto &ev, const auto &rv_ev) {
LOG(OrderMan, Info,
"SpreaderFractionalQtyHelper::in_transform_order_event sec_key: {} "
@@ -149,14 +92,8 @@ SpreaderFractionalQtyHelper::in_transform_order_event(
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;
double qmult = me->in_qty_mult;
me->op_ord.quantity *= qmult;
me->op_ord.filled_quantity *= qmult;
me->op_ord.filled_at_attach_time_quantity *= qmult;
@@ -166,21 +103,19 @@ SpreaderFractionalQtyHelper::in_transform_order_event(
Quantity SpreaderFractionalQtyHelper::in_transform_spreader_qty(
Quantity qty) const {
// nothing needs to be done with spreader qty
if (me->passthrough)
return qty;
return qty;
}
Quantity SpreaderFractionalQtyHelper::out_transform_leg_order_qty(
SecurityKey sec_key, Quantity qty) const {
SecurityKey, 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);
double qm = me->in_qty_mult;
return Quantity::create_new(qty.full_value() / qm);
};
auto rv_qty = tr();
LOG(OrderMan, Info,
@@ -190,12 +125,13 @@ Quantity SpreaderFractionalQtyHelper::out_transform_leg_order_qty(
return rv_qty;
}
const bts::api::orderman::OrderState &
SpreaderFractionalQtyHelper::out_transform_order_state(
bts::api::orderman::OrderState &ord_st) {
if (me->passthrough)
return ord_st;
return ord_st;
void SpreaderFractionalQtyHelper::out_transform_order_state(
bts::api::orderman::OrderState &) const {
// todo:
// this needs to divide the filled qty of the spreader
// if (me->passthrough)
// return ord_st;
// return ord_st;
}
} // namespace bts::orderman
@@ -1,8 +1,8 @@
#pragma once
#include "SpreaderLegData.h"
#include "lib/domain_model/common.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
//#include "SpreaderLegData.h"
//#include "lib/domain_model/common.h"
//#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orders/spreader_orders/spreader/LegPropertyData.h"
namespace bts::api::orderman {
@@ -19,16 +19,18 @@ class SpreaderFractionalQtyHelper {
public:
SpreaderFractionalQtyHelper(
OrderKey spreader_ord_key, const std::vector<LegPropertyData> &legs);
const std::vector<LegPropertyData> &legs() const;
// the leg qtys need to be translated
std::vector<LegPropertyData> get_transformed_legs(
const std::vector<LegPropertyData> &legs) const;
// in_ and out_ signify market data / orders coming in or out.
const Book &in_transform_book(const Book &book);
const Book &in_transform_book(const Book &book) const;
// this is called when the order feedback fomr the outside in to the spreader
const OrderStateUpdateEvent &in_transform_order_event(
SecurityKey sec_key, const OrderStateUpdateEvent &);
SecurityKey sec_key, const OrderStateUpdateEvent &) const;
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 &);
// the state reported ot he rest of the system also has to be converted
void out_transform_order_state(bts::api::orderman::OrderState &) const;
private:
struct PImpl;
@@ -107,6 +107,7 @@ class SpreaderLegData {
bts_assert(false);
return *_quoter_child_order_state;
}
// quoting order for the leg
const SpreaderChildOrderState &order_update_message() const {
// bts_assert(_is_quoting);
if (!_is_quoting)
@@ -7,8 +7,8 @@ namespace orderman {
class IAlternateOrderGateway {
public:
virtual void
place_order(SecurityKey, OrderKey, api::Side, Price, Quantity) = 0;
virtual void place_order(
bool is_quote, SecurityKey, OrderKey, api::Side, Price, Quantity) = 0;
virtual void modify_order(OrderKey, Price, Quantity) = 0;
virtual void cancel_order(OrderKey) = 0;
virtual OrderKey generate_key() = 0;
@@ -103,6 +103,7 @@ void SpreaderStartStateWorker::on_activate(
// events)
order_services.order_services().subscribe_to_child_updates(
[this](const bts::orderman::OrderStateUpdateEvent &os) {
// all external orders (quoting or heding for any leg) end up here
_spreader->_on_child_order_update(os);
});
// 5. sub to market data
@@ -4,12 +4,14 @@
#include "lib/io/websocket/WebsocketClient.h"
#include "lib/md/IMarketDataListener.h"
#include "lib/orderman/orderman_utils/Book.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h"
#include "lib/orderman/orders/spreader_orders/spreader_states/SpreaderState.h"
#include "lib/orderman/orders/spreader_orders/tests/tests_common.h"
#include "lib/os/os.h"
#include "lib/utils/helper_macros.h"
#include <boost/container/flat_set.hpp>
#include <catch/catch.hpp>
#include <stdio.h>
#include <time.h>
#include <tuple>
@@ -24,6 +26,7 @@ namespace orderman {
// reduced quantity due to other legs
// output price, qty
TEST_CASE("quoter price quantity state", "[spreader]") {
return;
// construction
ContractLeg leg_1;
fill_future_contract_leg(
@@ -5958,546 +5961,115 @@ TEST_CASE("spreader_main", "[spreader2]") {
leg_data_1.quoter(), QuoterState::WAITING_FOR_FIRST_ACK, false,
spreader_price, Quantity(1 * 1000), Quantity(0), Quantity(0),
Price(1997), Quantity(1000), Quantity(1000), false);
return;
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(0), Price(2002), Quantity(100),
Quantity(100), false);
// send fill on leg 1 (20)
std::cout << "------ n_ords: " << alt_order_gateway.actions.size()
<< std::endl;
const auto &last_ord = alt_order_gateway.actions.at(0);
REQUIRE(last_ord.op == AltOrderGatewayForTest::Action::PLACE_ORDER);
REQUIRE(last_ord.price.value() == 1997);
REQUIRE(last_ord.qty.full_value() == 1.0);
// ack'ing the quoter order
spreader.test_only_on_child_order_update(
leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(20), Price(2000));
leg_data_1.order_update_message().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity::create_new(0.0), Price(1997));
// means no further requotes
REQUIRE(alt_order_gateway.actions.size() == 1);
const SpreaderChildOrderState &q_ord = leg_data_1.order_update_message();
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(20), Quantity(0), Price(2000), Quantity(100),
Quantity(80), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(20), Price(2002), Quantity(80),
Quantity(80), false);
// send another fill on leg 1 (10)
Quantity(1 * 1000), Quantity(0), Quantity(0), Price(1997),
Quantity(1000), Quantity(1000), false);
// modify hedging book and validate requote
push_book(
spreader, 1, new double[5]{2000, 1999, 1998, 1997, 1996},
new md::Size[5]{1.2, 0.5, 0.1, 0.3, 1.0},
new double[5]{2001, 2002, 2003, 2004, 2005},
new md::Size[5]{0.1, 0.2, 0.3, 0.4, 0.5});
REQUIRE(alt_order_gateway.actions.size() == 2);
const auto &mod_ord1 =
alt_order_gateway.actions.at(alt_order_gateway.actions.size() - 1);
REQUIRE(mod_ord1.op == AltOrderGatewayForTest::Action::Op::MODIFY_ORDER);
REQUIRE(mod_ord1.price.value() == 2000.0);
REQUIRE(mod_ord1.qty.full_value() == 1.0);
// modify hedging book so that not enough hedge is avaibale, should reduce quoting qty
push_book(
spreader, 1, new double[5]{2000, 1999, 1998, 1997, 1996},
new md::Size[5]{0.1, 0.03, 0.07, 0.04, 0.06},
new double[5]{2001, 2002, 2003, 2004, 2005},
new md::Size[5]{0.1, 0.2, 0.3, 0.4, 0.5});
REQUIRE(alt_order_gateway.actions.size() == 3);
const auto &mod_ord2 =
alt_order_gateway.actions.at(alt_order_gateway.actions.size() - 1);
REQUIRE(mod_ord2.op == AltOrderGatewayForTest::Action::Op::MODIFY_ORDER);
REQUIRE(mod_ord2.price.value() == 1996);
REQUIRE(mod_ord2.qty.full_value() == 0.3);
// modify hedging book so that the total so available again (in anticpation of
// sending a fill)
push_book(
spreader, 1, new double[5]{2000, 1999, 1998, 1997, 1996},
new md::Size[5]{0.5, 0.5, 0.07, 0.04, 0.06},
new double[5]{2001, 2002, 2003, 2004, 2005},
new md::Size[5]{0.1, 0.2, 0.3, 0.4, 0.5});
REQUIRE(alt_order_gateway.actions.size() == 4);
const auto &mod_ord3 =
alt_order_gateway.actions.at(alt_order_gateway.actions.size() - 1);
REQUIRE(mod_ord3.op == AltOrderGatewayForTest::Action::Op::MODIFY_ORDER);
REQUIRE(mod_ord3.price.value() == 1999);
REQUIRE(mod_ord3.qty.full_value() == 1);
// send a fill, this should result in 2 things that need to be tested
// 1. requote
// 2. hedges
spreader.test_only_on_child_order_update(
leg_data_1.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(30), Price(2000));
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(0), Price(2000), Quantity(100),
Quantity(70), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(30), Price(2002), Quantity(70),
Quantity(70), false);
// send fill on leg 2 (15)
spreader.test_only_on_child_order_update(
leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(15), Price(2001));
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(15), Price(2001), Quantity(85),
Quantity(55), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(15), Quantity(30), Price(2002), Quantity(70),
Quantity(55), false);
// send another fill on leg 2 (30)
spreader.test_only_on_child_order_update(
leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(45), Price(2001));
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(45), Price(2002), Quantity(55),
Quantity(25), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(45), Quantity(30), Price(2000), Quantity(70),
Quantity(25), false);
// send another fill on leg 2 (10)
spreader.test_only_on_child_order_update(
leg_data_2.order_key(), api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity(55), Price(2001));
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(55), Price(2003), Quantity(45),
Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
Quantity(15), false);
// verify the hedgers
// leg 1 should have 3 hedgers, for each of the 3 fills
for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
// if(leg_data_1.get_hedger_test_only(i).is_active_order())
spreader.test_only_on_child_order_update(
leg_data_1.get_hedger_test_only(i).order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0));
for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
// if(leg_data_2.get_hedger_test_only(i).is_active_order())
spreader.test_only_on_child_order_update(
leg_data_2.get_hedger_test_only(i).order_state().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
Price(0));
REQUIRE(leg_data_1.n_active_hedgers() == 3);
REQUIRE(leg_data_2.n_active_hedgers() == 2);
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(30), Quantity(55), Price(2003), Quantity(45),
Quantity(15), false);
verify_complete_quoter_state(
leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
Quantity(15), false);
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
verify_complete_hedger_state(
leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
verify_complete_hedger_state(
leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
leg_data_1.order_update_message().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_WORKING,
Quantity::create_new(0.7), Price(1999));
// goes from 4 to 6 because of the hedge order
REQUIRE(alt_order_gateway.actions.size() == 6);
const auto &mod_ord4 =
alt_order_gateway.actions.at(alt_order_gateway.actions.size() - 1);
REQUIRE(mod_ord4.op == AltOrderGatewayForTest::Action::Op::MODIFY_ORDER);
REQUIRE(
mod_ord4.price.value() ==
2000); // with less qty needed, we cna move the price
REQUIRE(
mod_ord4.qty.full_value() ==
1.0); // qty is not changed, since we keep working the same order
const auto &hedge_ord =
alt_order_gateway.actions.at(alt_order_gateway.actions.size() - 2);
REQUIRE(hedge_ord.op == AltOrderGatewayForTest::Action::Op::PLACE_ORDER);
REQUIRE(
hedge_ord.price.value() ==
1999); // with less qty needed, we cna move the price
REQUIRE(hedge_ord.qty.full_value() == 0.7);
// qty is not changed, since we keep working the same order
// 2nd quoting fill //////////////////////////////////////////////
// send another fill. this should complete the quoting order and send another hedge
// auto generic_validate_quoters =
// [&](QuoterState quoter_state,
// bool quoter_cancelled_by_spreader) -> void {
// verify_complete_quoter_state(
// leg_data_1.quoter(), quoter_state, quoter_cancelled_by_spreader,
// spreader_price, Quantity(100), Quantity(30), Quantity(55),
// Price(2003), Quantity(45), Quantity(15), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), quoter_state, quoter_cancelled_by_spreader,
// spreader_price, Quantity(100), Quantity(55), Quantity(30),
// Price(2000), Quantity(70), Quantity(15), false);
// };
// auto generic_validate_hedgers = [&](HedgerState hedger_state) -> void {
// REQUIRE(leg_data_1.n_active_hedgers() == 3);
// REQUIRE(leg_data_2.n_active_hedgers() == 2);
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(0), hedger_state, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), hedger_state, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), hedger_state, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), hedger_state, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), hedger_state, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// };
// SECTION("1. init") {}
// SECTION("2. on_connect") {}
// SECTION("4. on_update") {
// // updating the spreader order should cause
// // the quoters to requote. hedgers should
// // be as is
// spreader_price = Price(0);
// spreader_quantity = Quantity(200);
// spreader.on_update(spreader_price, spreader_quantity);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
// spreader_quantity, Quantity(30), Quantity(55), Price(1998),
// Quantity(130), Quantity(115), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
// spreader_quantity, Quantity(55), Quantity(30), Price(2004),
// Quantity(165), Quantity(115), false);
// // nothing changes with the hedgers
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_update");
// }
// SECTION("5. on_cancel") {
// spreader.on_cancel();
// verify_basic_spreader_state(
// spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price,
// spreader_quantity);
// generic_validate_quoters(QuoterState::WAITING_FOR_CANCEL_ACK, true);
// generic_validate_hedgers(HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_cancel");
// }
// SECTION("6. on_book") {
// // 1. change the market such that it translates to no changes in order
// // leg 1 needs 15 more to get filled. the 15 cumulative size level in leg2
// // comes out to be at 2002, which gives leg1 = spreader_price + leg2 = 1 +
// // 2002 = 2003. changing leg 2's books such that 15 still comes at 2002
// uint32_t leg_1_id = leg_data_1.leg_property_data().security_key(),
// leg_2_id = leg_data_2.leg_property_data().security_key();
// bts::orderman::Book modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2004, 2003, 2002, 2001, 2000},
// new uint16_t[5]{5, 5, 5, 0, 0},
// new double[5]{2005, 2006, 2007, 2008, 2009},
// new uint16_t[5]{0, 0, 0, 0, 0}, true);
// spreader.test_only_on_book_update(modified_book);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// generic_validate_quoters(QuoterState::WORKING, false);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 2. change the market to induce a price change
// // we will go back to the prevoius market but make it thinner
// // to force leg 1's quoter to go deeper into leg 2's book
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{1, 1, 1, 1, 11},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(modified_book);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(30), Quantity(55), Price(1999), Quantity(45),
// Quantity(15), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
// Quantity(15), false);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 3. shrink to market to force a size change
// // the remaining target is 15, so we'll make the total
// // less than 15
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{1, 1, 1, 1, 0},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(modified_book);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(30), Quantity(55), Price(2000), Quantity(34),
// Quantity(15), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
// Quantity(15), false);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 4. change the market to force both a price and size change
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{1, 1, 13, 1, 1},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(modified_book);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(30), Quantity(55), Price(2001), Quantity(45),
// Quantity(15), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
// Quantity(15), false);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// // 5. remove the market
// // this should pull the order
// modified_book = get_book(
// SecurityKey(leg_2_id), 5, new double[5]{2002, 2001, 2000, 1999, 1998},
// new uint16_t[5]{0, 0, 0, 0, 0},
// new double[5]{2003, 2004, 2005, 2006, 2007},
// new uint16_t[5]{25, 25, 20, 20, 10}, true);
// // spreader.on_book (bts::orderman::trace::CorID(), modified_book);
// spreader.test_only_on_book_update(modified_book);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false,
// spreader_price, Quantity(100), Quantity(30), Quantity(55),
// Price(2001), Quantity(45), Quantity(15), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(55), Quantity(30), Price(2000), Quantity(70),
// Quantity(15), false);
// generic_validate_hedgers(HedgerState::WORKING);
// LOG(OrderMan, Diag, "spreader_WORKING.on_book");
// }
// SECTION("7. on_time") {}
// SECTION("8. on_quoter_order_error") {
// spreader.test_only_on_child_order_update(
// leg_data_1.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity(30),
// Price(2000));
// verify_basic_spreader_state(
// spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price,
// spreader_quantity);
// // the one that has an error goes to the end, the others are waiting on
// // cancel ack's
// REQUIRE(
// spreader.test_only_func_spreader_full_data()
// .get_leg_data(0)
// .quoter()
// .test_only_func_quoter_state() == QuoterState::END);
// REQUIRE(
// spreader.test_only_func_spreader_full_data()
// .get_leg_data(1)
// .quoter()
// .test_only_func_quoter_state() ==
// QuoterState::WAITING_FOR_CANCEL_ACK);
// generic_validate_hedgers(HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_error");
// }
// SECTION("9. on_quoter_order_fill") {
// // add one more hedge
// spreader.test_only_on_child_order_update(
// leg_data_2.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(65),
// Price(2001));
// for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(i).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(i).order_state().order_key(),
// api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// REQUIRE(leg_data_1.n_active_hedgers() == 4);
// REQUIRE(leg_data_2.n_active_hedgers() == 2);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(30), Quantity(65), Price(2003), Quantity(35),
// Quantity(5), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WORKING, false, spreader_price,
// Quantity(100), Quantity(65), Quantity(30), Price(1999), Quantity(70),
// Quantity(5), false);
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(3), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// SECTION("10. on_quoter_order_status_update") {
// // since order update has already been done in 9, lets fill
// // it completely
// spreader.test_only_on_child_order_update(
// leg_data_2.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(70),
// Price(2001));
// for (size_t i = 0; i < leg_data_1.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(i).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// for (size_t i = 0; i < leg_data_2.n_active_hedgers(); i++)
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(i).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(0),
// Price(0));
// REQUIRE(leg_data_1.n_active_hedgers() == 4);
// REQUIRE(leg_data_2.n_active_hedgers() == 2);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false,
// spreader_price, Quantity(100), Quantity(30), Quantity(70),
// Price(2003), Quantity(45), Quantity(0), true);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::END, false, spreader_price,
// Quantity(100), Quantity(0), Quantity(30), Price(0), Quantity(0),
// Quantity(0), true);
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(3), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
// SECTION("11. on_hedger_order_error") {
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_ERROR, Quantity(0),
// Price(0));
// verify_basic_spreader_state(
// spreader, SpreaderState::WAITING_FOR_CANCEL_ALL, spreader_price,
// spreader_quantity);
// generic_validate_quoters(QuoterState::WAITING_FOR_CANCEL_ACK, true);
// REQUIRE(
// leg_data_1.get_hedger_test_only(0).test_only_func_hedger_state() ==
// HedgerState::END);
// REQUIRE(
// leg_data_1.get_hedger_test_only(1).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(
// leg_data_1.get_hedger_test_only(2).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(
// leg_data_2.get_hedger_test_only(0).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// REQUIRE(
// leg_data_2.get_hedger_test_only(1).test_only_func_hedger_state() ==
// HedgerState::WAITING_FOR_CANCEL_ACK);
// LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_error");
// }
// SECTION("12. on_hedger_order_update") {
// // send as fill for the hedger
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING, Quantity(10),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// generic_validate_quoters(QuoterState::WORKING, false);
// REQUIRE(leg_data_1.n_active_hedgers() == 3);
// REQUIRE(leg_data_2.n_active_hedgers() == 2);
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(10), Price(2002), Quantity(15), Quantity(5));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// LOG(OrderMan, Diag, "spreader_WORKING.on_hedger_order_update");
// }
// SECTION("14. on_check_termination") {
// // the only way to do a termination and transit
// // to END is if the orders get filled. If we cancel
// // it leaves this state; if we send terminal status
// // on the quoters, and its not fully filled, the quoters
// // resubmit and continue
// // leg has 30 hedge deduction, and 55 filled, another 15 will fill it
// // completely
// spreader.test_only_on_child_order_update(
// leg_data_2.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(70),
// Price(2001));
// REQUIRE(leg_data_1.n_active_hedgers() == 4);
// REQUIRE(leg_data_2.n_active_hedgers() == 2);
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::WAITING_FOR_CANCEL_ACK, false,
// spreader_price, Quantity(100), Quantity(30), Quantity(70),
// Price(2003), Quantity(45), Quantity(0), true);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::END, false, spreader_price,
// Quantity(100), Quantity(0), Quantity(30), Price(0), Quantity(0),
// Quantity(0), true);
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(0), HedgerState::WORKING, Price(2002),
// Quantity(15), Quantity(0), Price(2002), Quantity(15), Quantity(15));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(1), HedgerState::WORKING, Price(2002),
// Quantity(30), Quantity(0), Price(2002), Quantity(30), Quantity(30));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(2), HedgerState::WORKING, Price(2002),
// Quantity(10), Quantity(0), Price(2002), Quantity(10), Quantity(10));
// verify_complete_hedger_state(
// leg_data_1.get_hedger_test_only(3),
// HedgerState::WAITING_FOR_FIRST_ACK, Price(2002), Quantity(15),
// Quantity(0), Price(2002), Quantity(15), Quantity(15)); // new hedger
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(0), HedgerState::WORKING, Price(1999),
// Quantity(20), Quantity(0), Price(1999), Quantity(20), Quantity(20));
// verify_complete_hedger_state(
// leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
// Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// // now bring the quoter and hedgers to their end states
// // when all of them are at the end state, the spreader
// // should also go to end
// spreader.test_only_on_child_order_update(
// leg_data_1.order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED, Quantity(30),
// Price(2001));
// verify_complete_quoter_state(
// leg_data_1.quoter(), QuoterState::END, false, spreader_price,
// Quantity(100), Quantity(0), Quantity(70), Price(0), Quantity(0),
// Quantity(0), true);
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// // // all the quoters are done now
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(15),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(1).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(30),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(2).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(10),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_1.get_hedger_test_only(3).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(15),
// Price(2002));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(0).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(20),
// Price(1999));
// verify_basic_spreader_state(
// spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
// spreader.test_only_on_child_order_update(
// leg_data_2.get_hedger_test_only(1).order_state().order_key(),
// bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED, Quantity(10),
// Price(1999));
// verify_basic_spreader_state(
// spreader, SpreaderState::END, spreader_price, spreader_quantity);
// LOG(OrderMan, Diag, "spreader_WORKING.on_quoter_order_fill");
// }
spreader.test_only_on_child_order_update(
leg_data_1.order_update_message().order_key(),
api::orderman::OrderStatus::ORDER_STATUS_COMPLETED,
Quantity::create_new(1.0), Price(2000));
// goes from 4 to 6 because of the hedge order
REQUIRE(alt_order_gateway.actions.size() == 7);
// hedging order
const auto &hedge_ord_2 =
alt_order_gateway.actions.at(alt_order_gateway.actions.size() - 1);
REQUIRE(hedge_ord_2.op == AltOrderGatewayForTest::Action::Op::PLACE_ORDER);
REQUIRE(hedge_ord_2.price.value() == 2000);
REQUIRE(hedge_ord_2.qty.full_value() == 0.3);
// quoting order should be done
REQUIRE(
leg_data_1.quoter().test_only_func_quoter_state() == QuoterState::END);
REQUIRE(leg_data_2.hedger_manager().n_active_hedgers() == 2);
REQUIRE(leg_data_1.order_update_message().completed());
Price avg_filled_pice;
Quantity filled_qty;
leg_data_1.order_update_message().total_fills(filled_qty, avg_filled_pice);
REQUIRE(filled_qty == 1000);
//std::cout << "avg_filled_price: " << avg_filled_pice << std::endl;
std::cout << std::endl
<< "Spreader qty: "
<< spreader.test_only_func_spreader_full_data().quantity();
}
} // namespace bts::orderman::tests
@@ -7,7 +7,9 @@
#include "lib/domain_model/common.h"
#include "lib/logging/logging.h"
#include "lib/md/PriceSize.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/securities/ISecurityDB.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/bts_chrono.h"
//#include "lib/utils/REQUIRE.h"
#include "lib/orderman/orders/spreader_orders/SpreaderOrder.h"
@@ -36,20 +38,28 @@ class AltOrderGatewayForTest : public IAlternateOrderGateway {
public:
class Action {
public:
enum Op { PLACE_ORDER, MODIFY_ORDER, CXL_ORDER };
enum Op { PLACE_ORDER = 0, MODIFY_ORDER, CXL_ORDER };
Op op;
OrderKey ok;
Price price;
Quantity qty;
};
std::vector<Action> actions;
void place_order(
SecurityKey sk, OrderKey ok, api::Side, Price p, Quantity q) override {
bool is_quote,
SecurityKey sk,
OrderKey ok,
api::Side,
Price p,
Quantity q) override {
LOG(OrderMan, Info,
"AltOrderGatewayForTest::place_order sec: {} ok: {} p: {} q: {}",
sk.value(), ok.value(), p.value(), q.value());
std::cout << "AltOrderGatewayForTest::place_order sec: " << sk.value()
<< " ok: " << ok.value() << " p: " << p.value()
<< " q: " << q.value() << std::endl;
"AltOrderGatewayForTest::place_order is_quote: {} sec: {} ok: {} p: "
"{} q: {}",
is_quote, sk.value(), ok.value(), p.value(), q.value());
std::cout << "AltOrderGatewayForTest::place_order is_quote: " << is_quote
<< " sec : " << sk.value() << " ok: " << ok.value()
<< " p: " << p.value() << " q: " << q.full_value() << std::endl;
actions.emplace_back(Action::PLACE_ORDER, ok, p, q);
}
void modify_order(OrderKey ok, Price p, Quantity q) override {
LOG(OrderMan, Info,
@@ -57,8 +67,8 @@ class AltOrderGatewayForTest : public IAlternateOrderGateway {
p.value(), q.value());
std::cout << "AltOrderGatewayForTest::modify_order "
<< " ok: " << ok.value() << " p: " << p.value()
<< " q: " << q.value() << std::endl;
actions.push_back({Action::PLACE_ORDER, p, q});
<< " q: " << q.full_value() << std::endl;
actions.push_back({Action::MODIFY_ORDER, ok, p, q});
}
void cancel_order(OrderKey ok) override {
LOG(OrderMan, Info, "AltOrderGatewayForTest::cancel_order ok: {} ",
@@ -80,7 +90,7 @@ class SpreaderManagerForTest : public ISpreaderManager {
SpreaderBookkeepingData _bookkeeping_data;
CacheWarmingState _cw_state;
AltOrderGatewayForTest _alt_order_gateway;
//SpreaderFractionalQtyHelper _fractional_qty_helper;
//SpreaderFractionalQtyHelper qty_helper;
public:
SpreaderManagerForTest(
@@ -141,6 +151,12 @@ class SpreaderManagerForTest : public ISpreaderManager {
IAlternateOrderGateway *alt_order_gateway() override {
return &_alt_order_gateway;
}
SpreaderFractionalQtyHelper const *spreader_qty_helper() override {
// bts_assert(false);
// return nullptr;
const SpreaderFractionalQtyHelper &rv = bookkeeping_data().fqty_helper();
return &rv;
}
bool in_cache_warming_cycle() const override { return false; }
// SpreaderFractionalQtyHelper &fractional_qty_helper() {