Added more etsts for fractional qtys

This commit is contained in:
Taha Afzal committed 2024-12-28 08:31:16 +00:00
1 parent ce96d42db8
commit 471faec2cb
6 files changed
+176 -97

No files matched your search

@@ -38,10 +38,10 @@ class QuoteLegPriceQuantityState {
QuoteLegPriceQuantityState() = delete;
QuoteLegPriceQuantityState(QuoteLegPriceQuantityState &&) = delete;
QuoteLegPriceQuantityState(const QuoteLegPriceQuantityState &) = delete;
QuoteLegPriceQuantityState &
operator=(const QuoteLegPriceQuantityState &) = delete;
QuoteLegPriceQuantityState &
operator=(QuoteLegPriceQuantityState &&) = delete;
QuoteLegPriceQuantityState &operator=(const QuoteLegPriceQuantityState &) =
delete;
QuoteLegPriceQuantityState &operator=(QuoteLegPriceQuantityState &&) =
delete;
// accessors ////////////////////
/////////////////////////////////
SpreaderChildOrderState &order_state() { return _order; }
@@ -66,20 +66,21 @@ class QuoteLegPriceQuantityState {
return Quantity(rv);
}
bool target_reached() const { return remaining_to_fill().value() == 0; }
// mutators /////////////////////
/////////////////////////////////
// this is used when the quoting order is cancelled (either
// bringing the quoter to the end or not)
// this adds the aggregated qty to the base qty, and resets
// everything (except accumulated hedge).
// mutators ////////////////////////////////////////////
////////////////////////////////////////////////////////
// the 2 mutators, called by SingleLegQuoter (and the various QuoterStateWorkers)
// are below
// called when the spreader price and qty are changed
void update_target_price_quantity(
Price new_target_spread_price, Quantity new_target_leg_quantity) {
_in_target_spread_price = new_target_spread_price;
_in_target_leg_quantity = new_target_leg_quantity;
}
// called when a fill happens for this leg. this increases the filled
// counter. this is needed to know the "remainder quantity" needed to price
// this leg called when a fill happens in one of the other quoting legs.
// happens on multi quoting leg scenario.
// called when a fill happens in another leg and a hedge is sent on this one, which means
// the quoting qty needs to be adjusted
void add_hedged_reduction(Quantity normalized_hedge_reduction) {
_aggregated_hedged_reduction = Quantity(
_aggregated_hedged_reduction.value() +
@@ -11,7 +11,7 @@ namespace bts {
namespace orderman {
// this wraps around the child order and performs the following :
// i. keeps track of last fills and average fill price
// ii. can mantain several orders, accumulating their fills
// ii. can cycle through several orders (though only one active at a atime) accumulating their fills
// into base fills
class SpreaderChildOrderState {
private:
@@ -1,9 +1,9 @@
#pragma once
#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"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderLegData.h"
namespace bts::api::orderman {
class OrderState;
@@ -3,7 +3,7 @@
namespace bts {
namespace orderman {
enum class QuoterState {
START,
START = 0,
WAITING_FOR_SIZE, // means, waiting for the hedge leg's market
WAITING_FOR_FIRST_ACK,
WAITING_FOR_IOC,
@@ -5858,36 +5858,16 @@ TEST_CASE("crossing_orders", "[spreader_matching]") {
namespace bts::orderman::tests {
// QuoteLegPriceQuantityState is used by the quoter
// to keep the state of the order state, ie
// target price, qty
// filled qty
// reduced quantity due to other legs
// output price, qty
// TEST_CASE("fractional_qtys", "[spreader2]") {
// int n = 1000000;
// for (int i = 0; i < n; i++) {
// int j = i;
// REQUIRE(i == j);
// }
// }
TEST_CASE("spreader_main", "[spreader2]") {
bts::orderman::OrderKey order_key(0);
Price spreader_price = Price(1);
Quantity spreader_quantity = Quantity(100);
Price spreader_price = Price(0);
Quantity spreader_quantity = Quantity(1);
ContractLeg leg_1, leg_2;
// fill_future_contract_leg(
// leg_1, 2468, "ES", bts::api::Venue::VENUE_GLBX, 2017, 12, 15, 1.0, 1.0,
// api::Side::SIDE_BUY, 1.0, 0.25);
// fill_future_contract_leg(
// leg_2, 13579, "ES", bts::api::Venue::VENUE_GLBX, 2018, 3, 15, -1.0, -1.0,
// api::Side::SIDE_SELL, 1.0, 0.25);
fill_spot_leg(
leg_1, 2468, "BTCUSD", bts::api::Venue::VENUE_BINANCE, 1.0, 1.0,
api::Side::SIDE_BUY, 1.0, 0.25);
fill_spot_leg(
leg_2, 13579, "BTCUSD", bts::api::Venue::VENUE_OKX, 1.0, 1.0,
leg_2, 13579, "BTCUSD", bts::api::Venue::VENUE_OKX, -1.0, -1.0,
api::Side::SIDE_SELL, 1.0, 0.25);
std::vector<ContractLeg> contract_legs;
contract_legs.push_back(leg_1);
@@ -5898,7 +5878,7 @@ TEST_CASE("spreader_main", "[spreader2]") {
// execution params/order def
LegSpreaderParams lsp_1, lsp_2, lsp_3;
fill_leg_spreader_params(lsp_1, 1.0, true, 1.0);
fill_leg_spreader_params(lsp_2, -1.0, true, 1.0);
fill_leg_spreader_params(lsp_2, -1.0, false, 1.0);
std::vector<LegSpreaderParams> spreader_params;
spreader_params.push_back(lsp_1);
spreader_params.push_back(lsp_2);
@@ -5912,12 +5892,9 @@ TEST_CASE("spreader_main", "[spreader2]") {
hedger_ord_defs;
SpreaderUtils::resolve_synthetic_spread(
pao_services, order_def, leg_props, quoter_ord_defs, hedger_ord_defs);
SpreaderManagerForTest spreader_manager(
order_key, order_def, pao_services, leg_props, quoter_ord_defs,
hedger_ord_defs);
AltOrderGatewayForTest alt_order_gateway;
// speader cons ////////////////////////////////////////
SpreaderOrder spreader(spreader_manager.alt_order_gateway());
SpreaderOrder spreader(&alt_order_gateway);
std::cout << "spreader(cons) state: "
<< static_cast<int>(spreader.test_only_func_spreader_state())
<< std::endl;
@@ -5940,32 +5917,48 @@ TEST_CASE("spreader_main", "[spreader2]") {
spreader, SpreaderState::WORKING, spreader_price, spreader_quantity);
SpreaderLegData &leg_data_1 = bookkeeping_data.get_leg_data(0);
SpreaderLegData &leg_data_2 = bookkeeping_data.get_leg_data(1);
//return;
// test list ///////////////////////////////////////////////////
// these are the following basic fractional qty tests at startup:
////////////////////////////////////////////////////////////////
// 1. leg qty multiplier
// 2. quoting target
// 3. book qty
// 4. fired order qty
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// test for leg qty ///////////////////////////////////
////////////////////////////////////////////////////////
const auto &leg_pd = spreader.get_leg_data(1);
REQUIRE(leg_pd.size_multiplier() == -1000.0);
// 2 quoting target ////////////////////////////////////
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WAITING_FOR_SIZE, false,
spreader_price, Quantity(100 * 1000), Quantity(0), Quantity(0), Price(0),
Quantity(0), Quantity(100 * 1000), false);
spreader_price, Quantity(1 * 1000), Quantity(0), Quantity(0), Price(0),
Quantity(0), Quantity(1 * 1000), false);
// verify_complete_quoter_state(
// leg_data_2.quoter(), QuoterState::WAITING_FOR_SIZE, false,
// spreader_price, Quantity(100), Quantity(0), Quantity(0), Price(0),
// Quantity(0), Quantity(100), false);
// temporary end //////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
return;
set_spreader_orders(
spreader, new double[5]{1999, 1998, 1997, 1996, 1995},
new uint16_t[5]{50, 50, 10, 10, 30},
new double[5]{2000, 2001, 2002, 2003, 2004},
new uint16_t[5]{10, 15, 25, 50, 10},
new double[5]{2002, 2001, 2000, 1999, 1998},
new uint16_t[5]{20, 20, 20, 20, 20},
new double[5]{2003, 2004, 2005, 2006, 2007},
new uint16_t[5]{25, 25, 20, 20, 10}, 0, 0, 0, 0);
push_book(
spreader, 1, new double[5]{2000, 1999, 1998, 1997, 1996},
new md::Size[5]{0.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});
// verify working orders
const Book &book = spreader.get_book(1);
//std::cout << "book: " << book << std::endl;
for (size_t i = 0; i < book.n_levels(); i++) {
std::cout << "level: " << i << " price: " << book.bid().at(i).price()
<< " sz: " << book.bid().at(i).size() << std::endl;
}
verify_complete_quoter_state(
leg_data_1.quoter(), QuoterState::WORKING, false, spreader_price,
Quantity(100), Quantity(0), Quantity(0), Price(1999), Quantity(100),
Quantity(100), false);
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),
@@ -6070,37 +6063,37 @@ TEST_CASE("spreader_main", "[spreader2]") {
leg_data_2.get_hedger_test_only(1), HedgerState::WORKING, Price(1999),
Quantity(10), Quantity(0), Price(1999), Quantity(10), Quantity(10));
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));
};
// 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") {
@@ -4,11 +4,15 @@
#include "lib/domain_model/Security.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/domain_model/common.h"
#include "lib/logging/logging.h"
#include "lib/md/PriceSize.h"
#include "lib/orderman/securities/ISecurityDB.h"
#include "lib/utils/bts_chrono.h"
//#include "lib/utils/REQUIRE.h"
#include "lib/orderman/orders/spreader_orders/SpreaderOrder.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderFractionalQtyHelper.h"
#include "lib/orderman/orders/spreader_orders/spreader/SpreaderLegData.h"
#include "lib/orderman/orders/spreader_orders/spreader/external_interfacing/IAlternateOrderGateway.h"
#include "lib/orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.h"
@@ -30,10 +34,38 @@ void fill_book(bts::orderman::Book &, double *, uint16_t *, bts::api::Side);
class AltOrderGatewayForTest : public IAlternateOrderGateway {
public:
class Action {
public:
enum Op { PLACE_ORDER, MODIFY_ORDER, CXL_ORDER };
Op op;
Price price;
Quantity qty;
};
std::vector<Action> actions;
void place_order(
SecurityKey, OrderKey, api::Side, Price, Quantity) override {}
void modify_order(OrderKey, Price, Quantity) override {}
void cancel_order(OrderKey) override {}
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;
}
void modify_order(OrderKey ok, Price p, Quantity q) override {
LOG(OrderMan, Info,
"AltOrderGatewayForTest::modify_order ok: {} p: {} q: {}", ok.value(),
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});
}
void cancel_order(OrderKey ok) override {
LOG(OrderMan, Info, "AltOrderGatewayForTest::cancel_order ok: {} ",
ok.value());
std::cout << "AltOrderGatewayForTest::cancel_order "
<< " ok: " << ok.value() << std::endl;
}
OrderKey generate_key() override {
auto rv =
static_cast<uint32_t>(bts::Timer::now().time_since_epoch().count());
@@ -48,6 +80,7 @@ class SpreaderManagerForTest : public ISpreaderManager {
SpreaderBookkeepingData _bookkeeping_data;
CacheWarmingState _cw_state;
AltOrderGatewayForTest _alt_order_gateway;
//SpreaderFractionalQtyHelper _fractional_qty_helper;
public:
SpreaderManagerForTest(
@@ -110,6 +143,10 @@ class SpreaderManagerForTest : public ISpreaderManager {
}
bool in_cache_warming_cycle() const override { return false; }
// SpreaderFractionalQtyHelper &fractional_qty_helper() {
// return _fractional_qty_helper;
// }
void place_order(ChildOrder &, Price, Quantity, SecurityKey, bool) override {
}
void update_order(
@@ -451,6 +488,34 @@ bts::orderman::Book get_book(
}
return bts::orderman::Book(key, bidside, askside);
}
bts::orderman::Book build_book(
SecurityKey key,
size_t n_bid_levels,
double *bid_prices,
md::Size *bid_sizes,
size_t n_ask_levels,
double *ask_prices,
md::Size *ask_sizes,
bool delete_arrays) {
bts::orderman::BookSide bidside, askside;
for (size_t i = 0; i < n_bid_levels; i++) {
bts::md::PriceSize bid =
bts::md::PriceSize_from_double<6>(bid_prices[i], bid_sizes[i]);
bidside[i] = bid;
}
for (size_t i = 0; i < n_ask_levels; i++) {
bts::md::PriceSize ask =
bts::md::PriceSize_from_double<6>(ask_prices[i], ask_sizes[i]);
askside[i] = ask;
}
if (delete_arrays) {
delete[] bid_prices;
delete[] bid_sizes;
delete[] ask_prices;
delete[] ask_sizes;
}
return bts::orderman::Book(key, bidside, askside);
}
bts::orderman::Book get_book(
SecurityKey key,
size_t n_levels,
@@ -613,6 +678,8 @@ void verify_leg_data(
REQUIRE(l.leg_property_data().price_multiplier() == price_mult);
REQUIRE(l.leg_property_data().trading_side() == side);
}
// tests the state for a single leg's quote. state being tested
// includes target price and qty, filled qty , remaining target
void verify_complete_quoter_state(
const SingleLegQuoter &quoter,
QuoterState quoter_state,
@@ -755,8 +822,26 @@ void validate_book(
delete[] sizes;
}
}
// fires the book update to the spreader legs
// and then an order update
void push_book(
SpreaderOrder &spreader,
size_t leg_idx,
double *bid_prices,
md::Size *bid_sizes,
double *ask_prices,
md::Size *ask_sizes) {
SpreaderBookkeepingData &bookkeeping_data =
spreader.test_only_func_spreader_full_data();
SpreaderLegData &leg_data = bookkeeping_data.get_leg_data(leg_idx);
uint32_t leg_id = leg_data.leg_property_data().security_key();
bts::orderman::Book book = build_book(
SecurityKey(leg_id), 5, bid_prices, bid_sizes, 5, ask_prices, ask_sizes,
true);
spreader.test_only_on_book_update(bts::orderman::BookUpdateEvent(book));
}
// fires the book update to 2 spreader legs
// and then 2 order udpates for each leg
void set_spreader_orders(
SpreaderOrder &spreader,
double *leg_1_bid_prices,