Add: rakurai dex execution
This commit is contained in:
1 parent
5a87288aaa
commit
1ffaf7c05b
8 files changed
+1806
-22
No files matched your search
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"account": "DEX_DEV",
|
||||
"operator_id": "DEX_DEV",
|
||||
"json_conf_file_name": "config.json",
|
||||
"default_priority_fee": 1000
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"account": "DEX_DEV",
|
||||
"operator_id": "DEX_DEV",
|
||||
"json_conf_file_name": "config.json",
|
||||
"default_priority_fee": 1000
|
||||
}
|
||||
@@ -4,6 +4,7 @@
|
||||
#include "binance/spots/spots_gateway.h"
|
||||
#include "binance/usds_futures/usds_futures_gateway.h"
|
||||
#include "okx_execution/okx_execution_gateway.h"
|
||||
#include "sparkd/execution/rakurai/rakurai_execution_gateway.h"
|
||||
#include "onixs_fix/OnixFIXAdapter.h"
|
||||
#include "python_interop/plugin_manager.h"
|
||||
#include "spark/api/domain/Venue.h"
|
||||
@@ -119,6 +120,18 @@ struct ExecutionGatewayProvider::PImpl {
|
||||
conn, conn.venue(), std::make_unique<OnixFIXAdapter>(o), o);
|
||||
case api::VENUE_OKX:
|
||||
return make_gw<OkxExecutionGateway>(conn, o);
|
||||
case api::VENUE_ORCA:
|
||||
case api::VENUE_RAYDIUM: {
|
||||
auto cfg_j = load_config_json(conn.name());
|
||||
bts_assert_msgf(
|
||||
cfg_j,
|
||||
"Failed to load execution gateway config. name: {}",
|
||||
conn.name());
|
||||
auto cfg = cfg_j->get<rakurai::GatewayConfig>();
|
||||
cfg.expand_env();
|
||||
return make_gw<rakurai::RakuraiExecutionGateway>(
|
||||
conn, o, std::move(cfg), conn);
|
||||
}
|
||||
case api::VENUE_BINANCE: {
|
||||
auto cfg =
|
||||
parse_config_json<binance::GatewayConfig>(conn.name());
|
||||
|
||||
@@ -0,0 +1,742 @@
|
||||
#include "sparkd/execution/rakurai/rakurai_execution_gateway.h"
|
||||
|
||||
#include "spark/config/config.h"
|
||||
#include "spark/config/protos/system_config.pb.h"
|
||||
#include "spark/domain/DomainSecurityUtils.h"
|
||||
#include "spark/domain/Price.h"
|
||||
#include "spark/domain/Quantity.h"
|
||||
#include "spark/domain_model/Security.h"
|
||||
#include "spark/logging/logging.h"
|
||||
#include "spark/md/SecurityOracle.h"
|
||||
#include "spark/orderman/CancelOrderMsg.h"
|
||||
#include "spark/orderman/CancelReplaceOrderMsg.h"
|
||||
#include "spark/orderman/CreateOrderMsg.h"
|
||||
#include "spark/orderman/RFQMsg.h"
|
||||
#include "spark/orderman/events/NewAdminDataEvent.h"
|
||||
#include "spark/orderman/events/NewSecuritiesEvent.h"
|
||||
#include "spark/orderman/orderman_utils/CancelReject.h"
|
||||
#include "spark/orderman/orderman_utils/ExecutionReport.h"
|
||||
#include "spark/orderman/orderman_utils/orderman_common.h"
|
||||
#include "spark/utils/bts_assert.h"
|
||||
#include "sparkd/rakurai/RakuraiSharedRuntime.h"
|
||||
|
||||
#include <boost/filesystem/path.hpp>
|
||||
|
||||
#include <cmath>
|
||||
#include <cstdint>
|
||||
#include <deque>
|
||||
#include <limits>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <unordered_map>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace bts::orderman::rakurai {
|
||||
|
||||
namespace {
|
||||
|
||||
#define LOG_FN(level, fn, ...) \
|
||||
LOG(OrderMan, level, "RakuraiExecutionGateway::" fn ". " __VA_ARGS__)
|
||||
#define WARN_FN(fn, ...) LOG_FN(Warn, fn, __VA_ARGS__)
|
||||
|
||||
using ConnectorNewOrder = ::rakurai::dex_connector::order_entry::new_order;
|
||||
using ConnectorOrderState = ::rakurai::dex_connector::order_entry::order_state;
|
||||
using ConnectorSide = ::rakurai::dex_connector::order_entry::side;
|
||||
|
||||
std::optional<std::string> extract_short_pool_id(const api::Security& security) {
|
||||
std::string desc;
|
||||
if (!domain::DomainSecurityUtils::get_security_desc(security, desc)) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto pos = desc.rfind('-');
|
||||
if (pos == std::string::npos || pos + 1 >= desc.size()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
return desc.substr(pos + 1);
|
||||
}
|
||||
|
||||
api::orderman::NativeOrderStatus to_order_status(ConnectorOrderState state) {
|
||||
using Status = ::rakurai::dex_connector::data_types::txn_status_t;
|
||||
switch (state.tx_status) {
|
||||
case Status::accepted:
|
||||
return api::orderman::NATIVE_ORDER_STATUS_NEW;
|
||||
case Status::confirmed:
|
||||
return state.is_pass ? api::orderman::NATIVE_ORDER_STATUS_FILLED
|
||||
: api::orderman::NATIVE_ORDER_STATUS_REJECTED;
|
||||
case Status::failed:
|
||||
return api::orderman::NATIVE_ORDER_STATUS_REJECTED;
|
||||
case Status::pending:
|
||||
return api::orderman::NATIVE_ORDER_STATUS_PENDING_NEW;
|
||||
}
|
||||
return api::orderman::NATIVE_ORDER_STATUS_UNDEFINED;
|
||||
}
|
||||
|
||||
api::orderman::ExecType to_exec_type(ConnectorOrderState state) {
|
||||
using Status = ::rakurai::dex_connector::data_types::txn_status_t;
|
||||
switch (state.tx_status) {
|
||||
case Status::accepted:
|
||||
return api::orderman::EXEC_TYPE_NEW;
|
||||
case Status::confirmed:
|
||||
return state.is_pass ? api::orderman::EXEC_TYPE_FILL
|
||||
: api::orderman::EXEC_TYPE_REJECTED;
|
||||
case Status::failed:
|
||||
return api::orderman::EXEC_TYPE_REJECTED;
|
||||
case Status::pending:
|
||||
return api::orderman::EXEC_TYPE_PENDING_NEW;
|
||||
}
|
||||
return api::orderman::EXEC_TYPE_UNDEFINED;
|
||||
}
|
||||
|
||||
std::string txn_status_name(
|
||||
::rakurai::dex_connector::data_types::txn_status_t status) {
|
||||
using Status = ::rakurai::dex_connector::data_types::txn_status_t;
|
||||
switch (status) {
|
||||
case Status::accepted:
|
||||
return "accepted";
|
||||
case Status::confirmed:
|
||||
return "confirmed";
|
||||
case Status::failed:
|
||||
return "failed";
|
||||
case Status::pending:
|
||||
return "pending";
|
||||
}
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
std::string json_for_log(const nlohmann::json& j) {
|
||||
try {
|
||||
return j.dump();
|
||||
} catch (const std::exception& ex) {
|
||||
return fmt::format("<json dump failed: {}>", ex.what());
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
struct RakuraiExecutionGateway::PImpl {
|
||||
struct ActiveOrder {
|
||||
CreateOrderMsg create_msg;
|
||||
trace::CorID cor_id;
|
||||
std::array<std::uint8_t, 32> pool_id{};
|
||||
double quantity_scale = 1.0;
|
||||
std::uint64_t raw_quantity = 0;
|
||||
std::uint64_t priority_fee = 0;
|
||||
std::uint64_t client_id = 0;
|
||||
std::uint64_t txn_id = 0;
|
||||
};
|
||||
|
||||
struct BufferedReport {
|
||||
std::shared_ptr<const ExecutionReport> report;
|
||||
trace::CorID cor_id;
|
||||
};
|
||||
|
||||
explicit PImpl(
|
||||
md::SecurityOracle,
|
||||
GatewayConfig cfg,
|
||||
config::JetFIX_Connection jetfix_connection)
|
||||
: config(std::move(cfg)),
|
||||
jetfix_connection(std::make_shared<config::JetFIX_Connection>(
|
||||
std::move(jetfix_connection))) {
|
||||
config.expand_env();
|
||||
venue = this->jetfix_connection->venue();
|
||||
bts_assert(venue == api::VENUE_ORCA || venue == api::VENUE_RAYDIUM);
|
||||
LOG_FN(
|
||||
Info,
|
||||
"ctor",
|
||||
"session:{} venue:{} account:{} operator_id:{} json_conf_file_name:{} default_priority_fee:{} connector_config:{}",
|
||||
this->jetfix_connection->name(),
|
||||
api::Venue_Name(venue),
|
||||
config.account,
|
||||
config.operator_id,
|
||||
config.json_conf_file_name,
|
||||
config.default_priority_fee,
|
||||
json_for_log(config.connector_config));
|
||||
}
|
||||
|
||||
GatewayConfig config;
|
||||
std::shared_ptr<config::JetFIX_Connection> jetfix_connection;
|
||||
api::Venue venue = api::VENUE_UNSET;
|
||||
std::mutex mutex;
|
||||
std::unordered_map<OrderKey, ActiveOrder> active_orders;
|
||||
std::unordered_map<std::uint64_t, OrderKey> client_id_to_order_key;
|
||||
std::deque<OrderKey> pending_client_bindings;
|
||||
std::deque<BufferedReport> buffered_reports;
|
||||
std::size_t order_update_subscription_id = 0;
|
||||
std::size_t status_subscription_id = 0;
|
||||
bool started = false;
|
||||
bool connected = false;
|
||||
OnExeReport exe_report;
|
||||
OnGwStatusChange gw_status_change;
|
||||
OnCancelReject cancel_reject;
|
||||
OnExchangePositionState exchange_position_state;
|
||||
OnExchangeOpenOrdersState exchange_open_orders;
|
||||
|
||||
void start() {
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
if (started) {
|
||||
LOG_FN(
|
||||
Info, "start", "already started. venue:{}",
|
||||
api::Venue_Name(venue));
|
||||
return;
|
||||
}
|
||||
started = true;
|
||||
}
|
||||
LOG_FN(
|
||||
Info,
|
||||
"start",
|
||||
"starting. session:{} venue:{} account:{} operator_id:{} json_conf_file_name:{} default_priority_fee:{}",
|
||||
jetfix_connection->name(),
|
||||
api::Venue_Name(venue),
|
||||
config.account,
|
||||
config.operator_id,
|
||||
config.json_conf_file_name,
|
||||
config.default_priority_fee);
|
||||
|
||||
auto& runtime = bts::rakurai::RakuraiSharedRuntime::instance();
|
||||
order_update_subscription_id =
|
||||
runtime.add_order_update_subscriber([this](ConnectorOrderState state) {
|
||||
this->on_order_update(state);
|
||||
});
|
||||
status_subscription_id =
|
||||
runtime.add_status_subscriber([this](bool is_connected_now) {
|
||||
this->on_status_change(is_connected_now);
|
||||
});
|
||||
|
||||
try {
|
||||
if (!config.json_conf_file_name.empty()) {
|
||||
const auto config_path =
|
||||
boost::filesystem::path{
|
||||
config::get<config::SystemConfig>().config_path()} /
|
||||
config.json_conf_file_name;
|
||||
LOG_FN(
|
||||
Info,
|
||||
"start",
|
||||
"ensuring shared runtime from file. path:{}",
|
||||
config_path.string());
|
||||
runtime.ensure_started_from_file(config_path.string());
|
||||
} else {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"start",
|
||||
"ensuring shared runtime from inline config. config:{}",
|
||||
json_for_log(config.connector_config));
|
||||
runtime.ensure_started_from_json(
|
||||
config.connector_config, jetfix_connection->name());
|
||||
}
|
||||
LOG_FN(
|
||||
Info,
|
||||
"start",
|
||||
"shared runtime start request submitted. order_update_sub_id:{} status_sub_id:{} connected_now:{}",
|
||||
order_update_subscription_id,
|
||||
status_subscription_id,
|
||||
runtime.is_connected());
|
||||
} catch (...) {
|
||||
runtime.remove_order_update_subscriber(order_update_subscription_id);
|
||||
runtime.remove_status_subscriber(status_subscription_id);
|
||||
order_update_subscription_id = 0;
|
||||
status_subscription_id = 0;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
started = false;
|
||||
}
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
void stop() {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"stop",
|
||||
"stopping. order_update_sub_id:{} status_sub_id:{}",
|
||||
order_update_subscription_id,
|
||||
status_subscription_id);
|
||||
auto& runtime = bts::rakurai::RakuraiSharedRuntime::instance();
|
||||
if (order_update_subscription_id != 0) {
|
||||
runtime.remove_order_update_subscriber(order_update_subscription_id);
|
||||
order_update_subscription_id = 0;
|
||||
}
|
||||
if (status_subscription_id != 0) {
|
||||
runtime.remove_status_subscriber(status_subscription_id);
|
||||
status_subscription_id = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void on_status_change(bool is_connected_now) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_status_change",
|
||||
"status update. venue:{} old_connected:{} new_connected:{} active_orders:{} pending_bindings:{} buffered_reports:{}",
|
||||
api::Venue_Name(venue),
|
||||
connected,
|
||||
is_connected_now,
|
||||
active_orders.size(),
|
||||
pending_client_bindings.size(),
|
||||
buffered_reports.size());
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
connected = is_connected_now;
|
||||
}
|
||||
if (gw_status_change) {
|
||||
gw_status_change(is_connected_now);
|
||||
}
|
||||
}
|
||||
|
||||
void on_order_update(ConnectorOrderState order_state) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_order_update",
|
||||
"incoming order update. client_id:{} txn_id:{} txn_status:{} is_pass:{} active_orders:{} pending_bindings:{} mapped_clients:{}",
|
||||
order_state.client_id,
|
||||
order_state.txn_id,
|
||||
txn_status_name(order_state.tx_status),
|
||||
order_state.is_pass,
|
||||
active_orders.size(),
|
||||
pending_client_bindings.size(),
|
||||
client_id_to_order_key.size());
|
||||
auto key_it = client_id_to_order_key.find(order_state.client_id);
|
||||
if (key_it == client_id_to_order_key.end()) {
|
||||
if (pending_client_bindings.empty()) {
|
||||
LOG_FN(
|
||||
Warn,
|
||||
"on_order_update",
|
||||
"dropping order update with unknown client_id:{} because there are no pending client bindings",
|
||||
order_state.client_id);
|
||||
return;
|
||||
}
|
||||
const auto key = pending_client_bindings.front();
|
||||
pending_client_bindings.pop_front();
|
||||
client_id_to_order_key.emplace(order_state.client_id, key);
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_order_update",
|
||||
"bound client_id:{} to order_key:{}",
|
||||
order_state.client_id,
|
||||
key.value());
|
||||
key_it = client_id_to_order_key.find(order_state.client_id);
|
||||
}
|
||||
|
||||
auto order_it = active_orders.find(key_it->second);
|
||||
if (order_it == active_orders.end()) {
|
||||
LOG_FN(
|
||||
Warn,
|
||||
"on_order_update",
|
||||
"dropping order update for client_id:{} mapped_order_key:{} because active order was not found",
|
||||
order_state.client_id,
|
||||
key_it->second.value());
|
||||
return;
|
||||
}
|
||||
|
||||
auto& active = order_it->second;
|
||||
active.client_id = order_state.client_id;
|
||||
active.txn_id = order_state.txn_id;
|
||||
auto report = build_report_locked(active, order_state);
|
||||
buffered_reports.push_back({std::move(report), active.cor_id});
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_order_update",
|
||||
"buffered execution report. order_key:{} client_id:{} txn_id:{} buffered_reports:{} order_status:{} exec_type:{}",
|
||||
active.create_msg.key.value(),
|
||||
active.client_id,
|
||||
active.txn_id,
|
||||
buffered_reports.size(),
|
||||
api::orderman::NativeOrderStatus_Name(
|
||||
buffered_reports.back().report->order_status),
|
||||
api::orderman::ExecType_Name(buffered_reports.back().report->exec_type));
|
||||
|
||||
const auto order_status = buffered_reports.back().report->order_status;
|
||||
if (order_status == api::orderman::NATIVE_ORDER_STATUS_FILLED ||
|
||||
order_status == api::orderman::NATIVE_ORDER_STATUS_REJECTED) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_order_update",
|
||||
"removing terminal active order. order_key:{} client_id:{} status:{}",
|
||||
active.create_msg.key.value(),
|
||||
order_state.client_id,
|
||||
api::orderman::NativeOrderStatus_Name(order_status));
|
||||
client_id_to_order_key.erase(order_state.client_id);
|
||||
active_orders.erase(order_it);
|
||||
}
|
||||
}
|
||||
|
||||
void send_create(const CreateOrderMsg& msg, trace::CorID cor_id) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
std::string security_desc = "<null>";
|
||||
if (msg.security != nullptr) {
|
||||
std::string desc;
|
||||
if (domain::DomainSecurityUtils::get_security_desc(*msg.security, desc)) {
|
||||
security_desc = std::move(desc);
|
||||
} else {
|
||||
security_desc = "<unresolved>";
|
||||
}
|
||||
}
|
||||
LOG_FN(
|
||||
Info,
|
||||
"send_create",
|
||||
"create request. order_key:{} venue:{} side:{} qty:{} price:{} tif:{} order_type:{} connected:{} security_present:{} desc:{}",
|
||||
msg.key.value(),
|
||||
api::Venue_Name(msg.venue()),
|
||||
api::Side_Name(msg.side),
|
||||
msg.quantity.full_value(),
|
||||
msg.price,
|
||||
api::orderman::TimeInForce_Name(msg.time_in_force),
|
||||
api::orderman::NativeOrderType_Name(msg.order_type),
|
||||
connected,
|
||||
msg.security != nullptr,
|
||||
security_desc);
|
||||
if (msg.security == nullptr) {
|
||||
enqueue_reject_locked(msg, cor_id, "Rakurai order missing security");
|
||||
return;
|
||||
}
|
||||
if (msg.venue() != venue) {
|
||||
enqueue_reject_locked(
|
||||
msg,
|
||||
cor_id,
|
||||
fmt::format(
|
||||
"Rakurai gateway venue mismatch. expected:{} actual:{}",
|
||||
api::Venue_Name(venue),
|
||||
api::Venue_Name(msg.venue())));
|
||||
return;
|
||||
}
|
||||
if (msg.order_type != api::orderman::NATIVE_ORDER_TYPE_MARKET) {
|
||||
enqueue_reject_locked(
|
||||
msg,
|
||||
cor_id,
|
||||
"Rakurai DEX gateway currently supports market orders only");
|
||||
return;
|
||||
}
|
||||
if (!connected) {
|
||||
enqueue_reject_locked(
|
||||
msg, cor_id, "Rakurai execution session is not connected");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto short_pool_id = extract_short_pool_id(*msg.security);
|
||||
if (!short_pool_id.has_value()) {
|
||||
enqueue_reject_locked(
|
||||
msg, cor_id, "Unable to derive Rakurai pool alias from security");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto metadata =
|
||||
bts::rakurai::RakuraiSharedRuntime::instance().find_pool_metadata(
|
||||
venue, *short_pool_id);
|
||||
if (!metadata.has_value()) {
|
||||
LOG_FN(
|
||||
Warn,
|
||||
"send_create",
|
||||
"pool metadata missing. venue:{} short_pool_id:{}",
|
||||
api::Venue_Name(venue),
|
||||
*short_pool_id);
|
||||
enqueue_reject_locked(
|
||||
msg,
|
||||
cor_id,
|
||||
"Rakurai pool metadata not available yet; wait for pool definitions");
|
||||
return;
|
||||
}
|
||||
|
||||
const auto raw_qty_f =
|
||||
msg.quantity.full_value() * metadata->quantity_scale;
|
||||
if (!std::isfinite(raw_qty_f) || raw_qty_f <= 0.0) {
|
||||
enqueue_reject_locked(
|
||||
msg, cor_id, "Rakurai order quantity must be positive");
|
||||
return;
|
||||
}
|
||||
|
||||
ConnectorNewOrder order;
|
||||
order.order_def.pool_id = metadata->security.pool_id;
|
||||
order.order_def.dex = metadata->security.venue;
|
||||
order.order_def.order_side =
|
||||
msg.side == api::SIDE_BUY ? ConnectorSide::buy : ConnectorSide::sell;
|
||||
order.qty = static_cast<std::uint64_t>(std::llround(raw_qty_f));
|
||||
order.priority_fee = config.default_priority_fee;
|
||||
LOG_FN(
|
||||
Info,
|
||||
"send_create",
|
||||
"launching new order. order_key:{} short_pool_id:{} raw_qty:{} priority_fee:{} dex:{} quantity_scale:{}",
|
||||
msg.key.value(),
|
||||
*short_pool_id,
|
||||
order.qty,
|
||||
order.priority_fee,
|
||||
static_cast<int>(metadata->security.venue),
|
||||
metadata->quantity_scale);
|
||||
|
||||
try {
|
||||
bts::rakurai::RakuraiSharedRuntime::instance().launch_new_order(order);
|
||||
} catch (const std::exception& ex) {
|
||||
WARN_FN(
|
||||
"send_create",
|
||||
"launch_new_order threw. order_key:{} reason:{}",
|
||||
msg.key.value(),
|
||||
std::string(ex.what()));
|
||||
enqueue_reject_locked(msg, cor_id, ex.what());
|
||||
return;
|
||||
}
|
||||
|
||||
active_orders.emplace(
|
||||
msg.key,
|
||||
ActiveOrder{
|
||||
msg,
|
||||
cor_id,
|
||||
metadata->security.pool_id,
|
||||
metadata->quantity_scale,
|
||||
order.qty,
|
||||
order.priority_fee});
|
||||
pending_client_bindings.push_back(msg.key);
|
||||
LOG_FN(
|
||||
Info,
|
||||
"send_create",
|
||||
"create request accepted locally. order_key:{} active_orders:{} pending_bindings:{}",
|
||||
msg.key.value(),
|
||||
active_orders.size(),
|
||||
pending_client_bindings.size());
|
||||
}
|
||||
|
||||
void send_cancel_reject(OrderKey key, const std::string& reason) {
|
||||
WARN_FN(
|
||||
"send_cancel_reject",
|
||||
"cancel reject. order_key:{} reason:{}",
|
||||
key.value(),
|
||||
reason);
|
||||
if (cancel_reject) {
|
||||
cancel_reject({key, CancelRejectReason::Other, reason});
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<const ExecutionReport> build_report_locked(
|
||||
const ActiveOrder& active,
|
||||
ConnectorOrderState state) const {
|
||||
auto report = std::make_shared<ExecutionReport>();
|
||||
report->account_name = account_name_for(active.create_msg);
|
||||
report->operator_id = operator_id_for(active.create_msg);
|
||||
report->order_key = active.create_msg.key;
|
||||
report->msg_seq_num = 0;
|
||||
report->security = active.create_msg.security;
|
||||
report->leg_security = nullptr;
|
||||
report->side = active.create_msg.side;
|
||||
report->time_in_force = active.create_msg.time_in_force;
|
||||
report->order_type = active.create_msg.order_type;
|
||||
report->manual_order_indicator = active.create_msg.manual_order_indicator;
|
||||
report->exchange = venue;
|
||||
report->cfg = jetfix_connection.get();
|
||||
report->exchange_order_id = ExchangeOrderID64(
|
||||
active.client_id != 0 ? active.client_id : state.txn_id);
|
||||
report->quantity = active.create_msg.quantity;
|
||||
report->price = active.create_msg.price;
|
||||
report->stop_price = active.create_msg.stop_px;
|
||||
report->max_show = active.create_msg.display_quantity;
|
||||
report->transact_time =
|
||||
ExchangeTimeStamp64(static_cast<std::uint64_t>(datetime::unix_nano_now()));
|
||||
report->exec_type = to_exec_type(state);
|
||||
report->order_status = to_order_status(state);
|
||||
report->filled_quantity =
|
||||
report->order_status == api::orderman::NATIVE_ORDER_STATUS_FILLED
|
||||
? active.create_msg.quantity
|
||||
: Quantity(0.0f);
|
||||
report->last_shares = report->filled_quantity;
|
||||
report->last_price = active.create_msg.price;
|
||||
report->avg_price = active.create_msg.price;
|
||||
report->msg = fmt::format(
|
||||
"Rakurai txn_status={} txn_id={} pass={}",
|
||||
txn_status_name(state.tx_status),
|
||||
state.txn_id,
|
||||
state.is_pass);
|
||||
LOG_FN(
|
||||
Info,
|
||||
"build_report_locked",
|
||||
"built report. order_key:{} client_id:{} txn_id:{} exec_type:{} order_status:{} message:{}",
|
||||
active.create_msg.key.value(),
|
||||
active.client_id,
|
||||
state.txn_id,
|
||||
api::orderman::ExecType_Name(report->exec_type),
|
||||
api::orderman::NativeOrderStatus_Name(report->order_status),
|
||||
report->msg);
|
||||
return report;
|
||||
}
|
||||
|
||||
void enqueue_reject_locked(
|
||||
const CreateOrderMsg& msg,
|
||||
trace::CorID cor_id,
|
||||
const std::string& reason) {
|
||||
auto report = std::make_shared<ExecutionReport>();
|
||||
report->account_name = account_name_for(msg);
|
||||
report->operator_id = operator_id_for(msg);
|
||||
report->order_key = msg.key;
|
||||
report->msg_seq_num = 0;
|
||||
report->security = msg.security;
|
||||
report->leg_security = nullptr;
|
||||
report->side = msg.side;
|
||||
report->time_in_force = msg.time_in_force;
|
||||
report->order_type = msg.order_type;
|
||||
report->manual_order_indicator = msg.manual_order_indicator;
|
||||
report->exchange = venue;
|
||||
report->cfg = jetfix_connection.get();
|
||||
report->exchange_order_id = ExchangeOrderID64(0);
|
||||
report->quantity = msg.quantity;
|
||||
report->filled_quantity = Quantity(0.0f);
|
||||
report->last_shares = Quantity(0.0f);
|
||||
report->price = msg.price;
|
||||
report->stop_price = msg.stop_px;
|
||||
report->max_show = msg.display_quantity;
|
||||
report->last_price = Price(std::numeric_limits<double>::quiet_NaN());
|
||||
report->avg_price = Price(std::numeric_limits<double>::quiet_NaN());
|
||||
report->transact_time =
|
||||
ExchangeTimeStamp64(static_cast<std::uint64_t>(datetime::unix_nano_now()));
|
||||
report->exec_type = api::orderman::EXEC_TYPE_REJECTED;
|
||||
report->order_status = api::orderman::NATIVE_ORDER_STATUS_REJECTED;
|
||||
report->msg = reason;
|
||||
buffered_reports.push_back({std::move(report), cor_id});
|
||||
WARN_FN(
|
||||
"enqueue_reject_locked",
|
||||
"buffered reject. order_key:{} reason:{} buffered_reports:{}",
|
||||
msg.key.value(),
|
||||
reason,
|
||||
buffered_reports.size());
|
||||
}
|
||||
|
||||
AccountName account_name_for(const CreateOrderMsg& msg) const {
|
||||
const auto account = msg.routing_record != nullptr &&
|
||||
!msg.routing_record->account().empty()
|
||||
? msg.routing_record->account()
|
||||
: config.account;
|
||||
AccountName result;
|
||||
result->copy_from(account);
|
||||
return result;
|
||||
}
|
||||
|
||||
OperatorID operator_id_for(const CreateOrderMsg& msg) const {
|
||||
const auto operator_id =
|
||||
msg.routing_record != nullptr &&
|
||||
!msg.routing_record->operator_id().empty()
|
||||
? msg.routing_record->operator_id()
|
||||
: config.operator_id;
|
||||
OperatorID result;
|
||||
orderman::to_array(operator_id, &result.value());
|
||||
return result;
|
||||
}
|
||||
};
|
||||
|
||||
RakuraiExecutionGateway::RakuraiExecutionGateway(
|
||||
md::SecurityOracle sec_oracle,
|
||||
GatewayConfig config,
|
||||
config::JetFIX_Connection jetfix_connection)
|
||||
: me_(std::make_unique<PImpl>(
|
||||
std::move(sec_oracle),
|
||||
std::move(config),
|
||||
std::move(jetfix_connection))) {}
|
||||
|
||||
RakuraiExecutionGateway::~RakuraiExecutionGateway() { me_->stop(); }
|
||||
|
||||
void RakuraiExecutionGateway::start() { me_->start(); }
|
||||
|
||||
void RakuraiExecutionGateway::dispatch_incoming_fix_messages() {
|
||||
std::deque<PImpl::BufferedReport> reports;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(me_->mutex);
|
||||
reports.swap(me_->buffered_reports);
|
||||
}
|
||||
|
||||
if (!reports.empty()) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"dispatch_incoming_fix_messages",
|
||||
"dispatching buffered reports. count:{} has_callback:{}",
|
||||
reports.size(),
|
||||
me_->exe_report != nullptr);
|
||||
}
|
||||
if (!me_->exe_report) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (auto& buffered : reports) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"dispatch_incoming_fix_messages",
|
||||
"publishing execution report. order_key:{} exec_type:{} order_status:{} msg:{}",
|
||||
buffered.report->order_key.value(),
|
||||
api::orderman::ExecType_Name(buffered.report->exec_type),
|
||||
api::orderman::NativeOrderStatus_Name(buffered.report->order_status),
|
||||
buffered.report->msg);
|
||||
me_->exe_report(std::move(buffered.report), buffered.cor_id);
|
||||
}
|
||||
}
|
||||
|
||||
void RakuraiExecutionGateway::on_securities(
|
||||
const mercury::Update<NewSecuritiesEvent>& update) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_securities",
|
||||
"received securities update. type:{} has_events:{} count:{}",
|
||||
static_cast<int>(update.event_type),
|
||||
update.events != nullptr,
|
||||
update.events != nullptr ? update.events->size() : 0);
|
||||
}
|
||||
|
||||
void RakuraiExecutionGateway::on_admin_data(
|
||||
const mercury::Update<NewAdminDataEvent>& update) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"on_admin_data",
|
||||
"received admin data update. type:{} has_events:{} count:{}",
|
||||
static_cast<int>(update.event_type),
|
||||
update.events != nullptr,
|
||||
update.events != nullptr ? update.events->size() : 0);
|
||||
}
|
||||
|
||||
void RakuraiExecutionGateway::send_fix(const jetfix::OutFIXPtr&, trace::CorID) {
|
||||
WARN_FN("send_fix", "FIX transport is not supported for Rakurai");
|
||||
}
|
||||
|
||||
void RakuraiExecutionGateway::send_msgs(
|
||||
std::vector<OrderMsg> const& msgs,
|
||||
trace::CorID cor_id) {
|
||||
LOG_FN(
|
||||
Info,
|
||||
"send_msgs",
|
||||
"received outbound message batch. count:{}",
|
||||
msgs.size());
|
||||
for (const auto& msg : msgs) {
|
||||
std::visit(
|
||||
[&](const auto& order_msg) {
|
||||
using T = std::decay_t<decltype(order_msg)>;
|
||||
if constexpr (std::is_same_v<T, CreateOrderMsg>) {
|
||||
me_->send_create(order_msg, cor_id);
|
||||
} else if constexpr (std::is_same_v<T, CancelOrderMsg>) {
|
||||
me_->send_cancel_reject(
|
||||
order_msg.key,
|
||||
"Rakurai DEX gateway does not support order cancel");
|
||||
} else if constexpr (std::is_same_v<T, CancelReplaceOrderMsg>) {
|
||||
me_->send_cancel_reject(
|
||||
order_msg.create_fields.key,
|
||||
"Rakurai DEX gateway does not support order replace");
|
||||
} else if constexpr (std::is_same_v<T, RFQMsg>) {
|
||||
WARN_FN("send_msgs", "RFQ is not supported for Rakurai");
|
||||
}
|
||||
},
|
||||
msg);
|
||||
}
|
||||
}
|
||||
|
||||
OnExeReport& RakuraiExecutionGateway::on_exe_report() { return me_->exe_report; }
|
||||
|
||||
OnGwStatusChange& RakuraiExecutionGateway::on_gw_status_change() {
|
||||
return me_->gw_status_change;
|
||||
}
|
||||
|
||||
OnCancelReject& RakuraiExecutionGateway::on_cancel_reject() {
|
||||
return me_->cancel_reject;
|
||||
}
|
||||
|
||||
OnExchangePositionState& RakuraiExecutionGateway::on_exchange_position_state() {
|
||||
return me_->exchange_position_state;
|
||||
}
|
||||
|
||||
OnExchangeOpenOrdersState& RakuraiExecutionGateway::on_exchange_open_orders() {
|
||||
return me_->exchange_open_orders;
|
||||
}
|
||||
|
||||
} // namespace bts::orderman::rakurai
|
||||
@@ -0,0 +1,76 @@
|
||||
#pragma once
|
||||
|
||||
#include "spark/io/JsonReader.h"
|
||||
#include "spark/orderman/gateways/IExecutionGateway.h"
|
||||
#include "spark/os/os.h"
|
||||
|
||||
#include <memory>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
namespace bts::config {
|
||||
class JetFIX_Connection;
|
||||
}
|
||||
|
||||
namespace bts::md {
|
||||
class SecurityOracle;
|
||||
}
|
||||
|
||||
namespace bts::orderman::rakurai {
|
||||
|
||||
struct GatewayConfig {
|
||||
std::string account;
|
||||
std::string operator_id;
|
||||
std::string json_conf_file_name;
|
||||
std::uint64_t default_priority_fee = 1000;
|
||||
nlohmann::json connector_config;
|
||||
|
||||
void expand_env() {
|
||||
bts::os::expand_env_in_place(account);
|
||||
bts::os::expand_env_in_place(operator_id);
|
||||
bts::os::expand_env_in_place(json_conf_file_name);
|
||||
}
|
||||
};
|
||||
|
||||
inline void from_json(const nlohmann::json& j, GatewayConfig& cfg) {
|
||||
cfg.connector_config = j;
|
||||
|
||||
const bts::io::JsonReader jr{&j};
|
||||
jr.read_or("account", cfg.account);
|
||||
jr.read_or("operator_id", cfg.operator_id);
|
||||
jr.read_or("json_conf_file_name", cfg.json_conf_file_name);
|
||||
jr.read_or("default_priority_fee", cfg.default_priority_fee);
|
||||
}
|
||||
|
||||
class RakuraiExecutionGateway : public IExecutionGateway {
|
||||
public:
|
||||
explicit RakuraiExecutionGateway(
|
||||
bts::md::SecurityOracle sec_oracle,
|
||||
GatewayConfig config,
|
||||
bts::config::JetFIX_Connection jetfix_connection);
|
||||
~RakuraiExecutionGateway() override;
|
||||
|
||||
void start() override;
|
||||
void dispatch_incoming_fix_messages() override;
|
||||
void on_securities(
|
||||
const bts::mercury::Update<bts::orderman::NewSecuritiesEvent>&)
|
||||
override;
|
||||
void on_admin_data(
|
||||
const bts::mercury::Update<bts::orderman::NewAdminDataEvent>&) override;
|
||||
void send_fix(const bts::jetfix::OutFIXPtr&, bts::trace::CorID) override;
|
||||
void send_msgs(
|
||||
std::vector<bts::orderman::OrderMsg> const&,
|
||||
bts::trace::CorID) override;
|
||||
|
||||
bts::orderman::OnExeReport& on_exe_report() override;
|
||||
bts::orderman::OnGwStatusChange& on_gw_status_change() override;
|
||||
bts::orderman::OnCancelReject& on_cancel_reject() override;
|
||||
bts::orderman::OnExchangePositionState&
|
||||
on_exchange_position_state() override;
|
||||
bts::orderman::OnExchangeOpenOrdersState& on_exchange_open_orders() override;
|
||||
|
||||
private:
|
||||
struct PImpl;
|
||||
std::unique_ptr<PImpl> me_;
|
||||
};
|
||||
|
||||
} // namespace bts::orderman::rakurai
|
||||
@@ -3,8 +3,7 @@
|
||||
#include "spark/config/config.h"
|
||||
#include "spark/config/protos/system_config.pb.h"
|
||||
#include "spark/logging/logging.h"
|
||||
#include "spark/utils/thread_manager.h"
|
||||
#include "sparkd/md/rakurai/RakuraiDexDataHandler.h"
|
||||
#include "sparkd/rakurai/RakuraiSharedRuntime.h"
|
||||
|
||||
#include <boost/filesystem/path.hpp>
|
||||
|
||||
@@ -24,6 +23,7 @@ struct RakuraiDexSubscription::PImpl {
|
||||
std::uint32_t num_depth_levels = 0;
|
||||
std::vector<std::string> excluded_securities;
|
||||
std::shared_ptr<persistence::IDGenerator> sec_id_store;
|
||||
std::size_t subscription_id = 0;
|
||||
};
|
||||
|
||||
RakuraiDexSubscription::RakuraiDexSubscription(
|
||||
@@ -46,33 +46,29 @@ void RakuraiDexSubscription::start(
|
||||
std::shared_ptr<IMarketDataListener> listener) {
|
||||
const auto config_path =
|
||||
Path{config::get<SystemConfig>().config_path()} / me_->json_conf_file_name;
|
||||
const auto thread_name =
|
||||
me_->venue == api::domain::VENUE_ORCA ? "rakurai_orca" : "rakurai_raydium";
|
||||
|
||||
LOG(md, Info,
|
||||
"Starting Rakurai DEX market data. venue:{} config:{}",
|
||||
int(me_->venue),
|
||||
config_path.string());
|
||||
|
||||
threading::make_thread(
|
||||
thread_name,
|
||||
[venue = me_->venue,
|
||||
config_file = config_path.string(),
|
||||
num_depth_levels = me_->num_depth_levels,
|
||||
excluded_securities = me_->excluded_securities,
|
||||
sec_id_store = me_->sec_id_store,
|
||||
listener = std::move(listener)]() mutable {
|
||||
rakurai::RakuraiDexDataHandler::run(
|
||||
std::move(listener),
|
||||
std::move(sec_id_store),
|
||||
venue,
|
||||
config_file,
|
||||
num_depth_levels,
|
||||
excluded_securities);
|
||||
})
|
||||
.detach();
|
||||
me_->subscription_id =
|
||||
rakurai::RakuraiSharedRuntime::instance().add_market_data_subscriber(
|
||||
std::move(listener),
|
||||
me_->sec_id_store,
|
||||
me_->venue,
|
||||
me_->num_depth_levels,
|
||||
me_->excluded_securities);
|
||||
rakurai::RakuraiSharedRuntime::instance().ensure_started_from_file(
|
||||
config_path.string());
|
||||
}
|
||||
|
||||
void RakuraiDexSubscription::stop() {}
|
||||
void RakuraiDexSubscription::stop() {
|
||||
if (me_->subscription_id != 0) {
|
||||
rakurai::RakuraiSharedRuntime::instance().remove_market_data_subscriber(
|
||||
me_->subscription_id);
|
||||
me_->subscription_id = 0;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace bts::md
|
||||
@@ -0,0 +1,867 @@
|
||||
#include "sparkd/rakurai/RakuraiSharedRuntime.h"
|
||||
|
||||
#include "spark/api/domain/SecurityType.pb.h"
|
||||
#include "spark/domain/Book.h"
|
||||
#include "spark/domain/Price.h"
|
||||
#include "spark/domain/Quantity.h"
|
||||
#include "spark/domain/Security.h"
|
||||
#include "spark/logging/logging.h"
|
||||
#include "spark/md/IMarketDataListener.h"
|
||||
#include "spark/persistence/IDGenerator.h"
|
||||
#include "spark/persistence/SqliteStore.h"
|
||||
#include "sparkd/md/MarketDataError.h"
|
||||
|
||||
#include <boost/filesystem/path.hpp>
|
||||
#include <dex_handler.h>
|
||||
#include <dex_listener.h>
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <array>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <fstream>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <optional>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <string_view>
|
||||
#include <thread>
|
||||
#include <unordered_map>
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace bts::rakurai {
|
||||
|
||||
namespace {
|
||||
|
||||
using ConnectorVenue = ::rakurai::dex_connector::data_types::venue;
|
||||
using ConnectorSecurity = ::rakurai::dex_connector::data_types::security;
|
||||
using ConnectorBookLevel = ::rakurai::dex_connector::data_types::book_level;
|
||||
using ConnectorDexConfig = ::rakurai::dex_connector::configuration::dex_config;
|
||||
|
||||
const char* connector_venue_name(ConnectorVenue venue) {
|
||||
switch (venue) {
|
||||
case ConnectorVenue::orca_clmm:
|
||||
return "orca_clmm";
|
||||
case ConnectorVenue::orca_amm:
|
||||
return "orca_amm";
|
||||
case ConnectorVenue::raydium_amm:
|
||||
return "raydium_amm";
|
||||
case ConnectorVenue::raydium_cpmm:
|
||||
return "raydium_cpmm";
|
||||
case ConnectorVenue::raydium_clmm:
|
||||
return "raydium_clmm";
|
||||
default:
|
||||
return "invalid";
|
||||
}
|
||||
}
|
||||
|
||||
bool venue_matches(api::domain::Venue spark_venue, ConnectorVenue connector_venue) {
|
||||
switch (spark_venue) {
|
||||
case api::domain::VENUE_ORCA:
|
||||
return connector_venue == ConnectorVenue::orca_clmm ||
|
||||
connector_venue == ConnectorVenue::orca_amm;
|
||||
case api::domain::VENUE_RAYDIUM:
|
||||
return connector_venue == ConnectorVenue::raydium_amm ||
|
||||
connector_venue == ConnectorVenue::raydium_cpmm ||
|
||||
connector_venue == ConnectorVenue::raydium_clmm;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool venue_matches(api::Venue spark_venue, ConnectorVenue connector_venue) {
|
||||
switch (spark_venue) {
|
||||
case api::VENUE_ORCA:
|
||||
return connector_venue == ConnectorVenue::orca_clmm ||
|
||||
connector_venue == ConnectorVenue::orca_amm;
|
||||
case api::VENUE_RAYDIUM:
|
||||
return connector_venue == ConnectorVenue::raydium_amm ||
|
||||
connector_venue == ConnectorVenue::raydium_cpmm ||
|
||||
connector_venue == ConnectorVenue::raydium_clmm;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
std::string bytes_to_hex(const std::array<std::uint8_t, 32>& bytes) {
|
||||
static constexpr char kHex[] = "0123456789abcdef";
|
||||
std::string out;
|
||||
out.reserve(bytes.size() * 2);
|
||||
for (std::uint8_t byte : bytes) {
|
||||
out.push_back(kHex[(byte >> 4) & 0x0f]);
|
||||
out.push_back(kHex[byte & 0x0f]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
std::string short_hex(const std::array<std::uint8_t, 32>& bytes) {
|
||||
const auto hex = bytes_to_hex(bytes);
|
||||
return hex.substr(0, std::min<std::size_t>(hex.size(), 12));
|
||||
}
|
||||
|
||||
std::string token_display_name(
|
||||
const ::rakurai::dex_connector::data_types::token_info& token) {
|
||||
return token.name.empty() ? short_hex(token.mint_address) : token.name;
|
||||
}
|
||||
|
||||
std::string build_security_desc(
|
||||
const ConnectorSecurity& security,
|
||||
std::string_view short_pool_id) {
|
||||
return fmt::format(
|
||||
"{}-{}-{}",
|
||||
token_display_name(security.token_a),
|
||||
token_display_name(security.token_b),
|
||||
short_pool_id);
|
||||
}
|
||||
|
||||
double quantity_scale_from_decimals(std::uint8_t decimals) {
|
||||
double scale = 1.0;
|
||||
for (std::uint8_t i = 0; i < decimals; ++i) {
|
||||
scale *= 10.0;
|
||||
}
|
||||
return scale;
|
||||
}
|
||||
|
||||
domain::BookLevel to_book_level(
|
||||
const ConnectorBookLevel& source,
|
||||
double quantity_scale) {
|
||||
domain::BookLevel level;
|
||||
level.price = domain::Price::from_double(source.price);
|
||||
const auto normalized_quantity =
|
||||
quantity_scale > 0.0
|
||||
? static_cast<double>(source.quantity) / quantity_scale
|
||||
: static_cast<double>(source.quantity);
|
||||
level.total_quantity =
|
||||
domain::Quantity(static_cast<float>(normalized_quantity));
|
||||
level.direct_quantity = level.total_quantity;
|
||||
level.n_orders = 0;
|
||||
return level;
|
||||
}
|
||||
|
||||
std::list<ConnectorDexConfig> parse_dex_configs(const nlohmann::json& config) {
|
||||
std::list<ConnectorDexConfig> dex_config_list;
|
||||
const auto dex_it = config.find("dex");
|
||||
if (dex_it == config.end() || !dex_it->is_array()) {
|
||||
return dex_config_list;
|
||||
}
|
||||
|
||||
for (const auto& dex_value : *dex_it) {
|
||||
if (!dex_value.is_object()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
ConnectorDexConfig dex_config;
|
||||
const std::string dex = dex_value.value("id", "");
|
||||
|
||||
if (dex == "orca_clmm") {
|
||||
dex_config.dex_name = ConnectorVenue::orca_clmm;
|
||||
dex_config.pool_typ =
|
||||
::rakurai::dex_connector::data_types::pool_type::clmm;
|
||||
} else if (dex == "orca_amm") {
|
||||
dex_config.dex_name = ConnectorVenue::orca_amm;
|
||||
dex_config.pool_typ =
|
||||
::rakurai::dex_connector::data_types::pool_type::amm;
|
||||
} else if (dex == "raydium_amm") {
|
||||
dex_config.dex_name = ConnectorVenue::raydium_amm;
|
||||
dex_config.pool_typ =
|
||||
::rakurai::dex_connector::data_types::pool_type::amm;
|
||||
} else if (dex == "raydium_cpmm") {
|
||||
dex_config.dex_name = ConnectorVenue::raydium_cpmm;
|
||||
dex_config.pool_typ =
|
||||
::rakurai::dex_connector::data_types::pool_type::cpmm;
|
||||
} else if (dex == "raydium_clmm") {
|
||||
dex_config.dex_name = ConnectorVenue::raydium_clmm;
|
||||
dex_config.pool_typ =
|
||||
::rakurai::dex_connector::data_types::pool_type::clmm;
|
||||
} else {
|
||||
LOG(md, Warn, "Skipping unsupported Rakurai dex config '{}'", dex);
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto pools_it = dex_value.find("pool_ids");
|
||||
if (pools_it != dex_value.end() && pools_it->is_array()) {
|
||||
for (const auto& pool_value : *pools_it) {
|
||||
dex_config.interested_pools.emplace_back(
|
||||
::rakurai::dex_connector::solanaAddressToBytes(
|
||||
pool_value.get<std::string>()));
|
||||
}
|
||||
}
|
||||
|
||||
dex_config_list.push_back(std::move(dex_config));
|
||||
}
|
||||
|
||||
return dex_config_list;
|
||||
}
|
||||
|
||||
nlohmann::json load_json_file(const std::string& path) {
|
||||
LOG(md, Info, "Rakurai shared runtime loading config file: {}", path);
|
||||
std::ifstream config_file(path);
|
||||
if (!config_file.is_open()) {
|
||||
throw std::runtime_error("Unable to open Rakurai config: " + path);
|
||||
}
|
||||
|
||||
nlohmann::json config;
|
||||
config_file >> config;
|
||||
|
||||
const auto nested_config_it = config.find("json_conf_file_name");
|
||||
if (nested_config_it != config.end() && nested_config_it->is_string() &&
|
||||
!config.contains("dex")) {
|
||||
const auto nested_name = nested_config_it->get<std::string>();
|
||||
auto nested_path = boost::filesystem::path(nested_name);
|
||||
if (nested_path.is_relative()) {
|
||||
nested_path = boost::filesystem::path(path).parent_path() / nested_path;
|
||||
}
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime resolved wrapper config '{}' -> '{}'. wrapper:{}",
|
||||
path,
|
||||
nested_path.string(),
|
||||
config.dump());
|
||||
return load_json_file(nested_path.string());
|
||||
}
|
||||
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime loaded connector config from '{}': {}",
|
||||
path,
|
||||
config.dump());
|
||||
return config;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
struct RakuraiSharedRuntime::PImpl {
|
||||
struct MarketDataSubscriber {
|
||||
std::size_t id = 0;
|
||||
std::shared_ptr<md::IMarketDataListener> listener;
|
||||
std::shared_ptr<persistence::IDGenerator> sec_id_store;
|
||||
api::domain::Venue venue = api::domain::VENUE_UNSPECIFIED;
|
||||
std::size_t depth_limit = domain::Book::max_depth();
|
||||
std::unordered_set<std::string> excluded_securities;
|
||||
std::unordered_map<std::string, std::unique_ptr<domain::Security>>
|
||||
securities;
|
||||
std::unordered_map<std::string, domain::SecurityID> pool_to_security_id;
|
||||
std::unordered_map<std::string, double> pool_quantity_scales;
|
||||
std::mutex mutex;
|
||||
};
|
||||
|
||||
struct ListenerAdapter final : public ::rakurai::dex_connector::dex_listener {
|
||||
explicit ListenerAdapter(PImpl& owner) : owner(owner) {}
|
||||
|
||||
void on_pool_definition(
|
||||
ConnectorVenue venue,
|
||||
const std::vector<ConnectorSecurity*>& securities) override {
|
||||
owner.on_pool_definition(venue, securities);
|
||||
}
|
||||
|
||||
void on_book(
|
||||
ConnectorVenue venue,
|
||||
const std::array<std::uint8_t, 32>& pool_id,
|
||||
const std::vector<ConnectorBookLevel>& bids,
|
||||
const std::vector<ConnectorBookLevel>& asks) override {
|
||||
owner.on_book(venue, pool_id, bids, asks);
|
||||
}
|
||||
|
||||
void on_order_update(
|
||||
::rakurai::dex_connector::order_entry::order_state order_state)
|
||||
override {
|
||||
owner.on_order_update(order_state);
|
||||
}
|
||||
|
||||
void on_ata_verification_status(
|
||||
const std::array<std::uint8_t, 32>& token_id,
|
||||
const std::string& ata_address,
|
||||
::rakurai::dex_connector::ata_status status) override {
|
||||
LOG(md, Info,
|
||||
"Rakurai ATA verification. token:{} ata:{} status:{}",
|
||||
short_hex(token_id),
|
||||
ata_address,
|
||||
static_cast<int>(status));
|
||||
}
|
||||
|
||||
PImpl& owner;
|
||||
};
|
||||
|
||||
mutable std::mutex mutex;
|
||||
std::optional<nlohmann::json> config;
|
||||
std::string config_label;
|
||||
std::optional<std::thread> run_thread;
|
||||
std::unique_ptr<::rakurai::dex_connector::dex_handler> handler;
|
||||
std::unique_ptr<::rakurai::dex_connector::trading_session_interface>
|
||||
trading_session;
|
||||
persistence::SqliteStore pool_alias_store{"rakurai_pool_alias"};
|
||||
ListenerAdapter listener{*this};
|
||||
std::unordered_map<std::size_t, std::shared_ptr<MarketDataSubscriber>>
|
||||
market_data_subscribers;
|
||||
std::unordered_map<std::size_t, OrderUpdateCallback> order_update_subscribers;
|
||||
std::unordered_map<std::size_t, StatusCallback> status_subscribers;
|
||||
std::unordered_map<std::string, PoolMetadata> pool_metadata;
|
||||
std::unordered_map<std::string, std::string> short_pool_to_full_pool;
|
||||
std::unordered_set<std::string> expected_pool_ids;
|
||||
std::unordered_set<std::string> resolved_pool_ids;
|
||||
std::size_t next_subscriber_id = 1;
|
||||
bool started = false;
|
||||
bool connected = false;
|
||||
|
||||
~PImpl() {
|
||||
if (run_thread.has_value() && run_thread->joinable()) {
|
||||
run_thread->detach();
|
||||
}
|
||||
}
|
||||
|
||||
std::size_t next_id_locked() { return next_subscriber_id++; }
|
||||
|
||||
void ensure_started(const nlohmann::json& cfg, const std::string& label) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime ensure_started requested. label:{} config:{}",
|
||||
label,
|
||||
cfg.dump());
|
||||
if (!config.has_value()) {
|
||||
config = cfg;
|
||||
config_label = label;
|
||||
} else if (*config != cfg) {
|
||||
throw std::runtime_error(
|
||||
"Rakurai shared runtime already configured with a different config source: " +
|
||||
config_label + " vs " + label);
|
||||
}
|
||||
|
||||
if (started) {
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime already started. label:{} connected:{}",
|
||||
config_label,
|
||||
connected);
|
||||
return;
|
||||
}
|
||||
started = true;
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime launching thread. label:{}",
|
||||
config_label);
|
||||
run_thread.emplace([this]() { run(); });
|
||||
}
|
||||
|
||||
std::size_t add_market_data_subscriber(
|
||||
std::shared_ptr<md::IMarketDataListener> listener_in,
|
||||
std::shared_ptr<persistence::IDGenerator> sec_id_store,
|
||||
api::domain::Venue venue,
|
||||
std::uint32_t num_depth_levels,
|
||||
const std::vector<std::string>& excluded_securities) {
|
||||
auto sub = std::make_shared<MarketDataSubscriber>();
|
||||
sub->listener = std::move(listener_in);
|
||||
sub->sec_id_store = std::move(sec_id_store);
|
||||
sub->venue = venue;
|
||||
sub->depth_limit =
|
||||
num_depth_levels == 0
|
||||
? domain::Book::max_depth()
|
||||
: std::min<std::size_t>(
|
||||
num_depth_levels, domain::Book::max_depth());
|
||||
sub->excluded_securities.insert(
|
||||
excluded_securities.begin(), excluded_securities.end());
|
||||
|
||||
std::vector<PoolMetadata> snapshot;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
sub->id = next_id_locked();
|
||||
market_data_subscribers.emplace(sub->id, sub);
|
||||
snapshot.reserve(pool_metadata.size());
|
||||
for (const auto& [_, metadata] : pool_metadata) {
|
||||
if (venue_matches(venue, metadata.security.venue)) {
|
||||
snapshot.push_back(metadata);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
replay_pool_definitions(*sub, snapshot);
|
||||
return sub->id;
|
||||
}
|
||||
|
||||
void remove_market_data_subscriber(std::size_t id) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
market_data_subscribers.erase(id);
|
||||
}
|
||||
|
||||
std::size_t add_order_update_subscriber(OrderUpdateCallback callback) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
const auto id = next_id_locked();
|
||||
order_update_subscribers.emplace(id, std::move(callback));
|
||||
return id;
|
||||
}
|
||||
|
||||
void remove_order_update_subscriber(std::size_t id) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
order_update_subscribers.erase(id);
|
||||
}
|
||||
|
||||
std::size_t add_status_subscriber(StatusCallback callback) {
|
||||
bool current_connected = false;
|
||||
std::size_t id = 0;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
id = next_id_locked();
|
||||
status_subscribers.emplace(id, callback);
|
||||
current_connected = connected;
|
||||
}
|
||||
callback(current_connected);
|
||||
return id;
|
||||
}
|
||||
|
||||
void remove_status_subscriber(std::size_t id) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
status_subscribers.erase(id);
|
||||
}
|
||||
|
||||
bool is_connected() const {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
return connected;
|
||||
}
|
||||
|
||||
void launch_new_order(const RakuraiSharedRuntime::NewOrder& order) {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
if (!connected || trading_session == nullptr) {
|
||||
throw std::runtime_error("Rakurai execution session is not connected");
|
||||
}
|
||||
trading_session->launch_new_order(order);
|
||||
}
|
||||
|
||||
std::optional<PoolMetadata> find_pool_metadata(
|
||||
api::Venue venue,
|
||||
const std::string& short_pool_id) const {
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
const auto pool_it = short_pool_to_full_pool.find(short_pool_id);
|
||||
if (pool_it == short_pool_to_full_pool.end()) {
|
||||
return std::nullopt;
|
||||
}
|
||||
const auto metadata_it = pool_metadata.find(pool_it->second);
|
||||
if (metadata_it == pool_metadata.end() ||
|
||||
!venue_matches(venue, metadata_it->second.security.venue)) {
|
||||
return std::nullopt;
|
||||
}
|
||||
return metadata_it->second;
|
||||
}
|
||||
|
||||
void run() {
|
||||
try {
|
||||
nlohmann::json connector_config;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
connector_config = *config;
|
||||
}
|
||||
|
||||
auto dex_configs = parse_dex_configs(connector_config);
|
||||
if (dex_configs.empty()) {
|
||||
throw std::runtime_error("No Rakurai dex pools configured");
|
||||
}
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime parsed config. dex_configs:{} config:{}",
|
||||
dex_configs.size(),
|
||||
connector_config.dump());
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
expected_pool_ids.clear();
|
||||
resolved_pool_ids.clear();
|
||||
for (const auto& dex_config : dex_configs) {
|
||||
for (const auto& pool_id : dex_config.interested_pools) {
|
||||
expected_pool_ids.insert(bytes_to_hex(pool_id));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
::rakurai::dex_connector::configuration::logging_config logging_config;
|
||||
if (connector_config.contains("app_logging")) {
|
||||
const auto& app_logging = connector_config.at("app_logging");
|
||||
logging_config.severity =
|
||||
app_logging.value("severity", logging_config.severity);
|
||||
logging_config.is_console_enabled =
|
||||
app_logging.value("console", logging_config.is_console_enabled);
|
||||
logging_config.is_file_enabled =
|
||||
app_logging.value("file", logging_config.is_file_enabled);
|
||||
logging_config.queue_size =
|
||||
app_logging.value("queuesize", logging_config.queue_size);
|
||||
}
|
||||
|
||||
::rakurai::dex_connector::configuration::wallet wallet_config;
|
||||
wallet_config.wallet_pub_key =
|
||||
::rakurai::dex_connector::solanaAddressToBytes(
|
||||
connector_config.at("wallet_pub").get<std::string>());
|
||||
const auto& wallet_pvt = connector_config.at("wallet_pvt");
|
||||
if (!wallet_pvt.is_array() ||
|
||||
wallet_pvt.size() != wallet_config.wallet_pvt_key.size()) {
|
||||
throw std::runtime_error(
|
||||
"Rakurai wallet_pvt must contain 64 integer entries");
|
||||
}
|
||||
for (std::size_t i = 0; i < wallet_config.wallet_pvt_key.size(); ++i) {
|
||||
wallet_config.wallet_pvt_key[i] =
|
||||
wallet_pvt.at(i).get<std::uint8_t>();
|
||||
}
|
||||
|
||||
std::list<::rakurai::dex_connector::configuration::uri_config> uris;
|
||||
auto add_uri = [&](const char* md_key, const char* oms_key) {
|
||||
::rakurai::dex_connector::configuration::uri_config uri;
|
||||
uri.md_server_uri =
|
||||
connector_config.at(md_key).get<std::string>();
|
||||
uri.node_oms_uri =
|
||||
connector_config.at(oms_key).get<std::string>();
|
||||
uris.push_back(std::move(uri));
|
||||
};
|
||||
add_uri("md_server_uri_1", "node_oms_uri_1");
|
||||
const bool cluster_mode =
|
||||
connector_config.value("cluster_mode", false);
|
||||
if (cluster_mode) {
|
||||
add_uri("md_server_uri_2", "node_oms_uri_2");
|
||||
}
|
||||
|
||||
const auto core = connector_config.value("core", 0U);
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
handler = std::make_unique<::rakurai::dex_connector::dex_handler>(
|
||||
dex_configs,
|
||||
wallet_config,
|
||||
logging_config,
|
||||
uris,
|
||||
core,
|
||||
cluster_mode,
|
||||
&listener);
|
||||
trading_session = std::make_unique<
|
||||
::rakurai::dex_connector::trading_session_interface>(
|
||||
handler->create_new_trading_session());
|
||||
connected = false;
|
||||
}
|
||||
|
||||
handler->run();
|
||||
} catch (const std::exception& ex) {
|
||||
LOG(md, Error, "Rakurai shared runtime failed: {}", std::string(ex.what()));
|
||||
notify_md_error(ex.what());
|
||||
}
|
||||
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
connected = false;
|
||||
}
|
||||
notify_status(false);
|
||||
}
|
||||
|
||||
void notify_status(bool is_connected_now) {
|
||||
std::vector<StatusCallback> callbacks;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
for (const auto& [_, callback] : status_subscribers) {
|
||||
callbacks.push_back(callback);
|
||||
}
|
||||
}
|
||||
for (auto& callback : callbacks) {
|
||||
callback(is_connected_now);
|
||||
}
|
||||
}
|
||||
|
||||
void notify_md_error(const std::string& message) {
|
||||
std::vector<std::shared_ptr<md::IMarketDataListener>> listeners;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
for (const auto& [_, sub] : market_data_subscribers) {
|
||||
listeners.push_back(sub->listener);
|
||||
}
|
||||
}
|
||||
for (const auto& listener_ptr : listeners) {
|
||||
if (!listener_ptr) {
|
||||
continue;
|
||||
}
|
||||
md::MarketDataError error;
|
||||
error.type = md::MarketDataError::DISCONNECTION;
|
||||
error.message = message;
|
||||
listener_ptr->on_error(error);
|
||||
}
|
||||
}
|
||||
|
||||
void load_aliases_locked() {
|
||||
if (!short_pool_to_full_pool.empty()) {
|
||||
return;
|
||||
}
|
||||
|
||||
constexpr std::string_view kPoolAliasNamespace = "rakurai_pool_alias";
|
||||
for (const auto& [ns, rows] : pool_alias_store.retrieve_all()) {
|
||||
if (ns != kPoolAliasNamespace) {
|
||||
continue;
|
||||
}
|
||||
for (const auto& [full_pool_id, alias] : rows) {
|
||||
if (!alias.empty()) {
|
||||
short_pool_to_full_pool.emplace(alias, full_pool_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::string get_or_add_short_pool_id_locked(const std::string& pool_id) {
|
||||
constexpr std::string_view kPoolAliasNamespace = "rakurai_pool_alias";
|
||||
const auto [exists, rowid, _] =
|
||||
pool_alias_store.retrieve_one(std::string(kPoolAliasNamespace), pool_id);
|
||||
if (exists) {
|
||||
const auto alias = std::to_string(rowid);
|
||||
short_pool_to_full_pool.emplace(alias, pool_id);
|
||||
return alias;
|
||||
}
|
||||
|
||||
const auto new_id =
|
||||
pool_alias_store.insert(std::string(kPoolAliasNamespace), pool_id, "");
|
||||
const auto alias = std::to_string(new_id);
|
||||
short_pool_to_full_pool.emplace(alias, pool_id);
|
||||
return alias;
|
||||
}
|
||||
|
||||
void on_pool_definition(
|
||||
ConnectorVenue connector_venue,
|
||||
const std::vector<ConnectorSecurity*>& securities) {
|
||||
std::vector<std::shared_ptr<MarketDataSubscriber>> subscribers;
|
||||
std::vector<PoolMetadata> touched;
|
||||
bool should_notify_ready = false;
|
||||
std::size_t resolved_pool_count = 0;
|
||||
std::size_t expected_pool_count = 0;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
load_aliases_locked();
|
||||
for (const auto* security : securities) {
|
||||
if (security == nullptr) {
|
||||
continue;
|
||||
}
|
||||
const auto pool_id = bytes_to_hex(security->pool_id);
|
||||
pool_metadata[pool_id] = PoolMetadata{
|
||||
*security,
|
||||
pool_id,
|
||||
get_or_add_short_pool_id_locked(pool_id),
|
||||
quantity_scale_from_decimals(security->token_a.decimals)};
|
||||
resolved_pool_ids.insert(pool_id);
|
||||
touched.push_back(pool_metadata.at(pool_id));
|
||||
}
|
||||
|
||||
const bool has_trading_session = trading_session != nullptr;
|
||||
const bool has_pool_definitions = !resolved_pool_ids.empty();
|
||||
const bool all_expected_pools_resolved =
|
||||
expected_pool_ids.empty()
|
||||
? has_pool_definitions
|
||||
: std::all_of(
|
||||
expected_pool_ids.begin(),
|
||||
expected_pool_ids.end(),
|
||||
[this](const std::string& pool_id) {
|
||||
return resolved_pool_ids.contains(pool_id);
|
||||
});
|
||||
if (!connected && has_trading_session && all_expected_pools_resolved) {
|
||||
connected = true;
|
||||
should_notify_ready = true;
|
||||
resolved_pool_count = resolved_pool_ids.size();
|
||||
expected_pool_count = expected_pool_ids.size();
|
||||
}
|
||||
|
||||
for (const auto& [_, sub] : market_data_subscribers) {
|
||||
if (venue_matches(sub->venue, connector_venue)) {
|
||||
subscribers.push_back(sub);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (should_notify_ready) {
|
||||
LOG(md, Info,
|
||||
"Rakurai shared runtime ready. resolved_pools:{} expected_pools:{}",
|
||||
resolved_pool_count,
|
||||
expected_pool_count);
|
||||
notify_status(true);
|
||||
}
|
||||
|
||||
for (const auto& sub : subscribers) {
|
||||
replay_pool_definitions(*sub, touched);
|
||||
}
|
||||
}
|
||||
|
||||
void replay_pool_definitions(
|
||||
MarketDataSubscriber& sub,
|
||||
const std::vector<PoolMetadata>& metadata_list) {
|
||||
std::lock_guard<std::mutex> lock(sub.mutex);
|
||||
std::vector<const domain::Security*> emitted;
|
||||
|
||||
for (const auto& metadata : metadata_list) {
|
||||
if (!venue_matches(sub.venue, metadata.security.venue)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto& security = metadata.security;
|
||||
const auto& pool_id = metadata.full_pool_id;
|
||||
const auto desc = build_security_desc(security, metadata.short_pool_id);
|
||||
const auto symbol = token_display_name(security.token_a);
|
||||
const auto currency = token_display_name(security.token_b);
|
||||
if (sub.excluded_securities.contains(pool_id) ||
|
||||
sub.excluded_securities.contains(metadata.short_pool_id) ||
|
||||
sub.excluded_securities.contains(desc)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
domain::Security emitted_security;
|
||||
emitted_security.security = domain::SpotSecurity{};
|
||||
emitted_security.security_common.venue = sub.venue;
|
||||
emitted_security.security_common.exchange_sec_id = metadata.short_pool_id;
|
||||
emitted_security.security_common.symbol = symbol;
|
||||
emitted_security.security_common.currency = currency;
|
||||
emitted_security.security_common.asset = symbol;
|
||||
emitted_security.security_common.group =
|
||||
connector_venue_name(security.venue);
|
||||
emitted_security.security_common.desc = desc;
|
||||
emitted_security.security_common.min_price_increment =
|
||||
security.min_tick > 0.0 ? security.min_tick : 0.0;
|
||||
emitted_security.security_common.min_quantity_increment =
|
||||
static_cast<double>(security.min_trade_amount);
|
||||
emitted_security.security_common.min_quantity =
|
||||
static_cast<double>(security.min_trade_amount);
|
||||
*emitted_security.security_common.id = sub.sec_id_store->get_or_add(
|
||||
sub.venue, api::domain::SECURITY_TYPE_SPOT, pool_id);
|
||||
|
||||
auto [it, is_new] = sub.securities.try_emplace(
|
||||
pool_id, std::make_unique<domain::Security>(std::move(emitted_security)));
|
||||
if (!is_new) {
|
||||
*it->second = std::move(emitted_security);
|
||||
}
|
||||
|
||||
sub.pool_to_security_id[pool_id] = it->second->id();
|
||||
sub.pool_quantity_scales[pool_id] = metadata.quantity_scale;
|
||||
emitted.push_back(it->second.get());
|
||||
}
|
||||
|
||||
if (!emitted.empty() && sub.listener) {
|
||||
sub.listener->on_securities(emitted);
|
||||
}
|
||||
}
|
||||
|
||||
void on_book(
|
||||
ConnectorVenue connector_venue,
|
||||
const std::array<std::uint8_t, 32>& pool_id,
|
||||
const std::vector<ConnectorBookLevel>& bids,
|
||||
const std::vector<ConnectorBookLevel>& asks) {
|
||||
std::vector<std::shared_ptr<MarketDataSubscriber>> subscribers;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
for (const auto& [_, sub] : market_data_subscribers) {
|
||||
if (venue_matches(sub->venue, connector_venue)) {
|
||||
subscribers.push_back(sub);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const auto pool_key = bytes_to_hex(pool_id);
|
||||
for (const auto& sub : subscribers) {
|
||||
std::lock_guard<std::mutex> lock(sub->mutex);
|
||||
const auto it = sub->pool_to_security_id.find(pool_key);
|
||||
if (it == sub->pool_to_security_id.end()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const auto quantity_scale_it = sub->pool_quantity_scales.find(pool_key);
|
||||
const auto quantity_scale =
|
||||
quantity_scale_it != sub->pool_quantity_scales.end()
|
||||
? quantity_scale_it->second
|
||||
: 1.0;
|
||||
|
||||
auto book = domain::Book::empty(it->second);
|
||||
const auto bid_depth =
|
||||
std::min<std::size_t>(sub->depth_limit, bids.size());
|
||||
const auto ask_depth =
|
||||
std::min<std::size_t>(sub->depth_limit, asks.size());
|
||||
|
||||
for (std::size_t i = 0; i < bid_depth; ++i) {
|
||||
book.bids()[i] = to_book_level(bids[i], quantity_scale);
|
||||
}
|
||||
for (std::size_t i = 0; i < ask_depth; ++i) {
|
||||
book.asks()[i] = to_book_level(asks[i], quantity_scale);
|
||||
}
|
||||
|
||||
if (sub->listener) {
|
||||
sub->listener->on_book(book);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void on_order_update(
|
||||
::rakurai::dex_connector::order_entry::order_state order_state) {
|
||||
std::vector<OrderUpdateCallback> callbacks;
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex);
|
||||
for (const auto& [_, callback] : order_update_subscribers) {
|
||||
callbacks.push_back(callback);
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& callback : callbacks) {
|
||||
callback(order_state);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
RakuraiSharedRuntime& RakuraiSharedRuntime::instance() {
|
||||
static RakuraiSharedRuntime runtime;
|
||||
return runtime;
|
||||
}
|
||||
|
||||
RakuraiSharedRuntime::RakuraiSharedRuntime()
|
||||
: me_(std::make_unique<PImpl>()) {}
|
||||
|
||||
RakuraiSharedRuntime::~RakuraiSharedRuntime() = default;
|
||||
|
||||
std::size_t RakuraiSharedRuntime::add_market_data_subscriber(
|
||||
std::shared_ptr<md::IMarketDataListener> listener,
|
||||
std::shared_ptr<persistence::IDGenerator> sec_id_store,
|
||||
api::domain::Venue venue,
|
||||
std::uint32_t num_depth_levels,
|
||||
const std::vector<std::string>& excluded_securities) {
|
||||
return me_->add_market_data_subscriber(
|
||||
std::move(listener),
|
||||
std::move(sec_id_store),
|
||||
venue,
|
||||
num_depth_levels,
|
||||
excluded_securities);
|
||||
}
|
||||
|
||||
void RakuraiSharedRuntime::remove_market_data_subscriber(std::size_t id) {
|
||||
me_->remove_market_data_subscriber(id);
|
||||
}
|
||||
|
||||
std::size_t RakuraiSharedRuntime::add_order_update_subscriber(
|
||||
OrderUpdateCallback callback) {
|
||||
return me_->add_order_update_subscriber(std::move(callback));
|
||||
}
|
||||
|
||||
void RakuraiSharedRuntime::remove_order_update_subscriber(std::size_t id) {
|
||||
me_->remove_order_update_subscriber(id);
|
||||
}
|
||||
|
||||
std::size_t RakuraiSharedRuntime::add_status_subscriber(StatusCallback callback) {
|
||||
return me_->add_status_subscriber(std::move(callback));
|
||||
}
|
||||
|
||||
void RakuraiSharedRuntime::remove_status_subscriber(std::size_t id) {
|
||||
me_->remove_status_subscriber(id);
|
||||
}
|
||||
|
||||
void RakuraiSharedRuntime::ensure_started_from_file(
|
||||
const std::string& config_path) {
|
||||
me_->ensure_started(load_json_file(config_path), config_path);
|
||||
}
|
||||
|
||||
void RakuraiSharedRuntime::ensure_started_from_json(
|
||||
const nlohmann::json& config,
|
||||
const std::string& config_label) {
|
||||
me_->ensure_started(config, config_label);
|
||||
}
|
||||
|
||||
bool RakuraiSharedRuntime::is_connected() const { return me_->is_connected(); }
|
||||
|
||||
void RakuraiSharedRuntime::launch_new_order(const NewOrder& order) {
|
||||
me_->launch_new_order(order);
|
||||
}
|
||||
|
||||
std::optional<RakuraiSharedRuntime::PoolMetadata>
|
||||
RakuraiSharedRuntime::find_pool_metadata(
|
||||
api::Venue venue,
|
||||
const std::string& short_pool_id) const {
|
||||
return me_->find_pool_metadata(venue, short_pool_id);
|
||||
}
|
||||
|
||||
} // namespace bts::rakurai
|
||||
@@ -0,0 +1,78 @@
|
||||
#pragma once
|
||||
|
||||
#include "spark/api/domain/Venue.pb.h"
|
||||
#include "spark/domain_model/Security.pb.h"
|
||||
|
||||
#include <dex_utils.h>
|
||||
#include <order_entry_common.h>
|
||||
|
||||
#include <cstddef>
|
||||
#include <functional>
|
||||
#include <memory>
|
||||
#include <nlohmann/json_fwd.hpp>
|
||||
#include <optional>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace bts::md {
|
||||
class IMarketDataListener;
|
||||
}
|
||||
|
||||
namespace bts::persistence {
|
||||
class IDGenerator;
|
||||
}
|
||||
|
||||
namespace bts::rakurai {
|
||||
|
||||
class RakuraiSharedRuntime {
|
||||
public:
|
||||
using OrderUpdate = ::rakurai::dex_connector::order_entry::order_state;
|
||||
using NewOrder = ::rakurai::dex_connector::order_entry::new_order;
|
||||
using OrderUpdateCallback = std::function<void(OrderUpdate)>;
|
||||
using StatusCallback = std::function<void(bool)>;
|
||||
|
||||
struct PoolMetadata {
|
||||
::rakurai::dex_connector::data_types::security security;
|
||||
std::string full_pool_id;
|
||||
std::string short_pool_id;
|
||||
double quantity_scale = 1.0;
|
||||
};
|
||||
|
||||
static RakuraiSharedRuntime& instance();
|
||||
|
||||
std::size_t add_market_data_subscriber(
|
||||
std::shared_ptr<md::IMarketDataListener> listener,
|
||||
std::shared_ptr<persistence::IDGenerator> sec_id_store,
|
||||
api::domain::Venue venue,
|
||||
std::uint32_t num_depth_levels,
|
||||
const std::vector<std::string>& excluded_securities);
|
||||
void remove_market_data_subscriber(std::size_t id);
|
||||
|
||||
std::size_t add_order_update_subscriber(OrderUpdateCallback callback);
|
||||
void remove_order_update_subscriber(std::size_t id);
|
||||
|
||||
std::size_t add_status_subscriber(StatusCallback callback);
|
||||
void remove_status_subscriber(std::size_t id);
|
||||
|
||||
void ensure_started_from_file(const std::string& config_path);
|
||||
void ensure_started_from_json(
|
||||
const nlohmann::json& config,
|
||||
const std::string& config_label);
|
||||
|
||||
bool is_connected() const;
|
||||
void launch_new_order(const NewOrder& order);
|
||||
std::optional<PoolMetadata> find_pool_metadata(
|
||||
api::Venue venue,
|
||||
const std::string& short_pool_id) const;
|
||||
|
||||
private:
|
||||
RakuraiSharedRuntime();
|
||||
~RakuraiSharedRuntime();
|
||||
RakuraiSharedRuntime(const RakuraiSharedRuntime&) = delete;
|
||||
RakuraiSharedRuntime& operator=(const RakuraiSharedRuntime&) = delete;
|
||||
|
||||
struct PImpl;
|
||||
std::unique_ptr<PImpl> me_;
|
||||
};
|
||||
|
||||
} // namespace bts::rakurai
|
||||
Reference in new issue
Block a user