repo_id
stringclasses 137
values | file_path
stringlengths 10
89
| content
stringlengths 0
990k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
src | /mono/crates/strategies/src/config.rs | use derive_more::Display;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use fdr_common::{crypto::assets::CurrencyPair, exchange::Exchange};
use strat_common::state_managers::strategy_manager::StrategyGetterTrait;
use crate::{
arbitrage::triangular_arbitrage::{TriangularArbitrage, TriangularArbitrageConfig},
market_makers::on_ticker::{MarketMakerOnTicker, MarketMakerOnTickerConfig},
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StrategyConfig {
pub strategy: StrategyConfigKind,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExchangeSubscription {
pub exchange: Exchange,
pub pairs: HashSet<CurrencyPair>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum StrategyConfigKind {
TriangularArbitrage(TriangularArbitrageConfig),
MarketMakerOnTicker(MarketMakerOnTickerConfig),
}
#[derive(Display)]
pub enum StrategyKind<T>
where
T: StrategyGetterTrait + Send + Sync,
{
#[display(fmt = "TriangularArbitrage: {:?}", "_0.subscribed_markets")]
TriangularArbitrage(TriangularArbitrage<T>),
#[display(fmt = "StaticFromTicker: {:?}", "_0.config.pair")]
MarketMakerOnTicker(MarketMakerOnTicker<T>),
}
| 0 |
src | /mono/crates/strategies/src/lib.rs | use crate::{
config::{StrategyConfigKind, StrategyKind},
error::{StrategyError, StrategyResult},
market_makers::on_ticker::MarketMakerOnTicker,
};
use arbitrage::triangular_arbitrage::TriangularArbitrage;
use derive_more::Display;
use fdr_store::core::pool::Pool;
use std::{
ops::{Deref, DerefMut},
sync::Arc,
};
use strat_common::{
crypto::market::UpdateRequest,
state_managers::{strategy_manager::StrategyGetterTrait, StateSubscriberTrait},
};
pub mod arbitrage;
pub mod config;
pub mod error;
pub mod market_makers;
#[derive(Display)]
pub struct Strategy<T>
where
T: StrategyGetterTrait + Send + Sync,
{
#[display(fmt = "Strategy: {}", inner)]
inner: StrategyKind<T>,
}
impl<T> Strategy<T>
where
T: StrategyGetterTrait + Send + Sync,
{
pub async fn new(parent_state: Arc<T>, config: StrategyConfigKind, pool: Arc<Pool>) -> StrategyResult<Self> {
let inner = match config {
StrategyConfigKind::MarketMakerOnTicker(inner_config) => StrategyKind::MarketMakerOnTicker(
MarketMakerOnTicker::new(parent_state, inner_config, pool.clone()).await?,
),
StrategyConfigKind::TriangularArbitrage(inner_config) => StrategyKind::TriangularArbitrage(
TriangularArbitrage::new(parent_state, inner_config, pool.clone()).await?,
),
};
Ok(Strategy { inner })
}
}
impl<T> Deref for Strategy<T>
where
T: StrategyGetterTrait + Send + Sync + 'static,
{
type Target = dyn StateSubscriberTrait<Vec<UpdateRequest>, StrategyError> + Send + Sync;
fn deref(&self) -> &Self::Target {
match self {
Strategy {
inner: StrategyKind::MarketMakerOnTicker(strategy),
} => strategy,
Strategy {
inner: StrategyKind::TriangularArbitrage(strategy),
} => strategy,
}
}
}
impl<T> DerefMut for Strategy<T>
where
T: StrategyGetterTrait + Send + Sync + 'static,
{
fn deref_mut(&mut self) -> &mut Self::Target {
match self {
Strategy {
inner: StrategyKind::MarketMakerOnTicker(strategy),
} => strategy,
Strategy {
inner: StrategyKind::TriangularArbitrage(strategy),
} => strategy,
}
}
}
| 0 |
market_makers | /mono/crates/strategies/src/market_makers/mod.rs | pub mod on_ticker;
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/price_strategy.rs | use crate::market_makers::on_ticker::MarketMakerOnTicker;
use async_trait::async_trait;
use fdr_common::{crypto::orders::FdrOrderSide, ticker::FdrTickerUpdate};
use price_guard::{error::PriceGuardResult, PriceGuard, PriceGuardTrait};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use strat_common::{
crypto::market::ticker_delta::MovingTickerDeltaAverage, price_strategies::PriceStrategy,
state_managers::strategy_manager::StrategyGetterTrait,
};
impl<T> MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
pub(crate) fn determine_desired_profit(
&self,
last_ticker: Option<FdrTickerUpdate>,
ticker_delta: &MovingTickerDeltaAverage,
) -> Decimal {
if let Some(last_ticker) = last_ticker {
let delta_based_profit = (ticker_delta.get_time_weighted_average(&last_ticker.timestamp) / dec!(1000))
* ticker_delta.get_coefficient().coefficient;
if delta_based_profit > self.config.desired_profit {
delta_based_profit
} else {
self.config.desired_profit
}
} else {
self.config.desired_profit
}
}
}
#[async_trait]
impl<T> PriceStrategy for MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
async fn get_price(
&self,
reference_price: &Decimal,
desired_profit: &Decimal,
order_level: &Decimal,
side: &FdrOrderSide,
) -> Decimal {
match side {
FdrOrderSide::Sell => reference_price * (Decimal::ONE + (desired_profit * order_level)),
FdrOrderSide::Buy => reference_price * (Decimal::ONE - (desired_profit * order_level)),
}
}
async fn apply_fees(&self, price: &Decimal, side: &FdrOrderSide, fees: &Decimal) -> Decimal {
match side {
FdrOrderSide::Buy => price / (Decimal::ONE + fees),
FdrOrderSide::Sell => price / (Decimal::ONE - fees),
}
}
async fn apply_price_guard(
&self,
price: &Decimal,
desired_profit: &Decimal,
order_level: &Decimal,
side: &FdrOrderSide,
price_guard: &PriceGuard,
) -> PriceGuardResult<Decimal> {
match side {
FdrOrderSide::Sell => {
if let Some(min_sell_price) = &price_guard.get_min_sell_price().await? {
if min_sell_price.is_zero() {
return Ok(*price);
}
if price <= min_sell_price {
return Ok(self.get_price(min_sell_price, order_level, desired_profit, side).await);
}
}
}
FdrOrderSide::Buy => {
if let Some(max_buy_price) = &price_guard.get_max_buy_price().await? {
if max_buy_price.is_zero() {
return Ok(*price);
}
if price >= max_buy_price {
return Ok(self.get_price(max_buy_price, order_level, desired_profit, side).await);
}
}
}
}
Ok(*price)
}
}
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/order_events.rs | use crate::{error::StrategyResult, market_makers::on_ticker::MarketMakerOnTicker};
use fdr_common::error::ExchangeError;
use fdr_event::events::{FdrOrderError, FdrOrderTrade};
use fdr_store::{
error::FdrStoreResult,
metrics::{models::BalanceMetricsDto, MetricsStore},
};
use price_guard::PriceGuardTrait;
use slog::{debug, warn};
use strat_common::{metrics::trades::TradeMetrics, state_managers::strategy_manager::StrategyGetterTrait};
impl<T> MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
pub(crate) async fn handle_order_error(&self, order_error: FdrOrderError) -> StrategyResult<()> {
debug!(self.parent_state.logger(), "Order Error: {:?}", order_error);
match &order_error.error {
ExchangeError::RateLimitExceeded | ExchangeError::InsufficientFunds => {
// TODO(25): Find a better measure for how long to wait before trying again
tokio::time::sleep(std::time::Duration::from_secs(60)).await;
}
_ => {
warn!(self.parent_state.logger(), "Unknown error: {:?}", order_error.error);
}
}
Ok(())
}
pub(crate) async fn handle_trade(&self, trade: FdrOrderTrade) -> StrategyResult<()> {
let before_balance = self.balances.get_balances().await?;
debug!(
self.parent_state.logger(),
"{:?}, Balance Before: {:?}", trade.market.pair, before_balance
);
debug!(self.parent_state.logger(), "Trade: {:?}", trade);
self.balances
.update_balances_on_trade(&trade, Some(self.last_ticker.read().await.last.timestamp))
.await?;
let after_balance = self.balances.get_balances().await?;
debug!(
self.parent_state.logger(),
"{:?} After Before: {:?}", trade.market.pair, after_balance
);
self.update_trade_metrics(Some(&trade)).await?;
self.update_balance_metrics().await?;
self.price_guard.write().await.apply_trade(&trade.try_into()?).await?;
Ok(())
}
pub async fn update_trade_metrics(&self, trade: Option<&FdrOrderTrade>) -> FdrStoreResult<u64> {
let mut db_conn = self.pool.acquire().await?;
let mut trade_metrics = self.get_latest_or_new_metrics().await?;
if let Some(trade) = trade {
trade_metrics.calculate(trade);
}
let rows_affected = db_conn.save_trade_metrics(&[trade_metrics.into()]).await?;
Ok(rows_affected)
}
async fn get_latest_or_new_metrics(&self) -> FdrStoreResult<TradeMetrics> {
let mut db_conn = self.pool.acquire().await?;
if let Some(metrics) = db_conn
.get_last_trade_metrics(
&self.config.strat_run_id,
&self.market.pair.base(),
&self.market.pair.quote(),
)
.await?
{
Ok(metrics.into())
} else {
Ok(TradeMetrics::new(
self.config.strat_run_id,
self.last_ticker.read().await.last.timestamp,
self.market.pair,
))
}
}
pub async fn update_balance_metrics(&self) -> StrategyResult<()> {
let mut db_conn = self.pool.acquire().await?;
let balances = self.balances.get_balances().await?;
let time = self.last_ticker.read().await.last.timestamp;
db_conn
.save_balance_metrics(&[
BalanceMetricsDto {
run_id: self.config.strat_run_id,
asset: self.market.pair.quote(),
balance: Some(balances.quote),
time,
},
BalanceMetricsDto {
run_id: self.config.strat_run_id,
asset: self.market.pair.base(),
balance: Some(balances.base),
time,
},
])
.await?;
Ok(())
}
}
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/build_orders.rs | use crate::{
error::StrategyResult,
market_makers::on_ticker::{volume::check_volume_against_balance, MarketMakerOnTicker},
};
use fdr_common::{
crypto::orders::{FdrOrderSide, FdrOrderStatus, FdrOrderType, OrderEntry},
exchange::Market,
};
use fdr_store::metrics::MetricsStore;
use rust_decimal::Decimal;
use std::ops::Deref;
use strat_common::{
crypto::market::MarketState, price_strategies::PriceStrategy, state_managers::strategy_manager::StrategyGetterTrait,
};
use tokio::sync::RwLockReadGuard;
use tracing::{instrument, Level};
use uuid::Uuid;
pub struct CalculateVolumeArgs<'a> {
pub price: &'a Decimal,
pub last_price: &'a Decimal,
pub side: &'a FdrOrderSide,
pub market_state: &'a RwLockReadGuard<'a, MarketState>,
pub average_cost: &'a Option<Decimal>,
pub total_quote_balance: &'a Decimal,
pub total_base_balance: &'a Decimal,
}
impl<T> MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
/// Builds a list of order entries for both buy and sell sides based on the given market state.
///
/// ## Parameters
///
/// - `&self` - A reference to the current instance of the struct.
/// - `market_state` - A reference to the market state.
///
/// ## Returns
///
/// A vector of `OrderEntry` containing the built orders.
#[instrument(skip(self), level = Level::DEBUG)]
pub(crate) async fn build_orders(
&self,
market_state: &RwLockReadGuard<'_, MarketState>,
orders: &[OrderEntry],
) -> StrategyResult<Vec<OrderEntry>> {
let desired_profit =
self.determine_desired_profit(market_state.last_ticker, &market_state.moving_ticker_delta_average);
let buys = self
.build_orders_for_side(&FdrOrderSide::Buy, market_state, &desired_profit, orders)
.await?;
let mut sells = self
.build_orders_for_side(&FdrOrderSide::Sell, market_state, &desired_profit, orders)
.await?;
// Just extending one of the two vectors to pass back all orders.
sells.extend(buys);
Ok(sells)
}
/// Builds an order entry based on the given parameters.
pub(crate) async fn build_order(&self, args: &BuildOrdersArgs<'_>) -> StrategyResult<Option<OrderEntry>> {
// Get balances
let balances = self.balances.get_balances().await?;
let mut locked_quote_balance = Decimal::ZERO;
let mut locked_base_balance = Decimal::ZERO;
for order in args.existing_orders.iter() {
if let Some((_, locked_balance)) = order.get_locked_balance() {
match order.side {
FdrOrderSide::Sell => {
locked_base_balance += locked_balance;
}
FdrOrderSide::Buy => {
locked_quote_balance += locked_balance;
}
}
}
}
let available_quote_balance = balances.quote - locked_quote_balance;
let available_base_balance = balances.base - locked_base_balance;
let Some(last_price) = args.market_state.last_ticker.and_then(|ticker| ticker.last_price) else {
return Ok(None);
};
let price = self
.create_price(
args.side,
&last_price,
args.order_level,
args.market_state,
args.desired_profit,
)
.await?;
let average_cost = self
.pool
.acquire()
.await?
.get_last_trade_metrics(
&self.config.strat_run_id,
&self.market.pair.base(),
&self.market.pair.quote(),
)
.await?
.map(|metric| metric.average_cost);
let calculated_volume = self.calculate_volume(CalculateVolumeArgs {
price: &price,
last_price: &last_price,
side: args.side,
market_state: args.market_state,
average_cost: &average_cost,
total_quote_balance: &balances.quote,
total_base_balance: &balances.base,
});
let volume = check_volume_against_balance(
&calculated_volume,
args.side,
&price,
&available_base_balance,
&available_quote_balance,
);
if volume < args.market_state.trading_pair.min_order {
return Ok(None);
}
// // Check the buckets
// let lock = self.bucket.read().await;
// let (price, volume) = lock.volume_that_can_be_covered(*args.side, price, volume);
Ok(Some(OrderEntry {
id: Uuid::new_v4(),
market: Market {
exchange: self.config.exchange,
pair: self.config.pair,
},
volume,
volume_remaining: volume,
side: *args.side,
price: Some(price),
order_status: FdrOrderStatus::New,
strategy: self.strategy,
type_: FdrOrderType::LimitMakerOnly,
strat_run_id: Some(self.config.strat_run_id),
}))
}
/// Creates a new price for an order.
///
/// # Arguments
///
/// * `side` - The order side.
/// * `last_price` - The last price.
/// * `order_level` - The order level.
/// * `market_state` - The market state.
///
/// # Returns
///
/// The created price for the order.
///
#[instrument(skip(self), level = Level::DEBUG)]
async fn create_price(
&self,
side: &FdrOrderSide,
last_price: &Decimal,
order_level: u32,
market_state: &RwLockReadGuard<'_, MarketState>,
desired_profit: &Decimal,
) -> StrategyResult<Decimal> {
let order_level = Decimal::from(order_level + 1);
let price = self.get_price(last_price, desired_profit, &order_level, side).await;
let price = self
.apply_price_guard(
&price,
desired_profit,
&order_level,
side,
self.price_guard.read().await.deref(),
)
.await?;
let price = self.apply_fees(&price, side, &market_state.fees.maker).await;
Ok(price.round_dp_with_strategy(
market_state.trading_pair.pair_decimals,
rust_decimal::RoundingStrategy::MidpointNearestEven,
))
}
#[instrument(skip(self), level = Level::DEBUG)]
async fn build_orders_for_side(
&self,
side: &FdrOrderSide,
market_state: &RwLockReadGuard<'_, MarketState>,
desired_profit: &Decimal,
existing_orders: &[OrderEntry],
) -> StrategyResult<Vec<OrderEntry>> {
let mut orders = vec![];
let order_count = existing_orders.iter().filter(|order| order.side == *side).count();
// TODO: This doesn't work for multiple order_levels, will have to be revisited.
for order_level in order_count as u32..self.config.max_orders {
let args = BuildOrdersArgs {
side,
order_level,
market_state,
desired_profit,
existing_orders,
};
if let Some(order) = self.build_order(&args).await? {
orders.push(order)
}
}
Ok(orders)
}
}
#[derive(Debug)]
pub struct BuildOrdersArgs<'a> {
pub side: &'a FdrOrderSide,
pub order_level: u32,
pub market_state: &'a RwLockReadGuard<'a, MarketState>,
pub desired_profit: &'a Decimal,
pub existing_orders: &'a [OrderEntry],
}
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/unique_orders.rs | use fdr_common::crypto::orders::OrderEntry;
use rust_decimal::Decimal;
use std::collections::HashMap;
use tracing::{instrument, Level};
// TODO: Update Tests
#[instrument(level = Level::DEBUG)]
pub(crate) fn build_unique_requests(
proposed_cancels: &[OrderEntry],
proposed_orders: &[OrderEntry],
) -> (Vec<OrderEntry>, Vec<OrderEntry>) {
let mut unique_prices = proposed_cancels
.iter()
.filter_map(|order| order.price.map(|price| (price, *order)))
.collect::<HashMap<Decimal, OrderEntry>>();
let mut unique_orders = Vec::with_capacity(proposed_orders.len());
proposed_orders.iter().for_each(|order| {
if let Some(price) = order.price {
// Check to see if the price already exists, if it does, this means we already have an order
// at that price and shouldn't update.
if unique_prices.contains_key(&price) {
unique_prices.remove(&price);
} else {
unique_orders.push(*order);
}
}
});
(unique_prices.into_values().collect(), unique_orders)
}
#[cfg(test)]
mod tests {
use super::*;
use fdr_common::{
crypto::{
assets::{Asset, CurrencyPair},
orders::{FdrOrderSide, FdrOrderStatus, OrderEntry},
},
exchange::Market,
TradingStrategy,
};
use rust_decimal_macros::dec;
use uuid::Uuid;
fn mock_orders() -> Vec<OrderEntry> {
let market = Market {
pair: CurrencyPair::new(Asset::Btc, Asset::Usd),
exchange: Default::default(),
};
vec![
OrderEntry {
id: Uuid::new_v4(),
market,
side: FdrOrderSide::Sell,
price: Some(dec!(5.01)),
volume: Default::default(),
volume_remaining: Default::default(),
order_status: FdrOrderStatus::New,
strategy: TradingStrategy::MarketMakerOnTicker,
type_: Default::default(),
strat_run_id: None,
},
OrderEntry {
id: Uuid::new_v4(),
market,
side: FdrOrderSide::Buy,
price: Some(dec!(4.99)),
volume: Default::default(),
volume_remaining: Default::default(),
order_status: FdrOrderStatus::New,
strategy: TradingStrategy::MarketMakerOnTicker,
type_: Default::default(),
strat_run_id: None,
},
]
}
#[test]
fn build_unique_requests_dupes() {
let orders = mock_orders();
let mut new_orders = mock_orders();
new_orders[0].id = Uuid::new_v4();
new_orders[1].id = Uuid::new_v4();
let (unique_requests, _) = build_unique_requests(&orders, &new_orders);
assert_eq!(unique_requests.len(), 0);
}
#[test]
fn build_unique_requests_no_dupes() {
let orders = mock_orders();
let mut new_orders = mock_orders();
new_orders[0].price = Some(dec!(5.02));
new_orders[1].price = Some(dec!(4.98));
new_orders[0].id = Uuid::new_v4();
new_orders[1].id = Uuid::new_v4();
let (cancels, new_orders) = build_unique_requests(&orders, &new_orders);
assert_eq!(cancels.len() + new_orders.len(), 4);
for order in new_orders {
assert!(order.price == Some(dec!(5.02)) || order.price == Some(dec!(4.98)));
}
for order in cancels {
assert!(order.id == orders[0].id || order.id == orders[1].id);
}
}
#[test]
fn build_unique_requests_some_dupes() {
let orders = mock_orders();
let mut new_orders = mock_orders();
new_orders[1].price = Some(dec!(4.98));
new_orders[0].id = Uuid::new_v4();
new_orders[1].id = Uuid::new_v4();
let (cancels, new_orders) = build_unique_requests(&orders, &new_orders);
assert_eq!(cancels.len(), 1);
assert_eq!(new_orders.len(), 1);
for order in new_orders {
assert_eq!(order.price, Some(dec!(4.98)));
}
for order in cancels {
assert_eq!(order.id, orders[1].id);
}
}
#[test]
fn build_unique_requests_empty_arrays() {
let (cancels, new_orders) = build_unique_requests(&[], &[]);
assert_eq!(cancels.len(), 0);
assert_eq!(new_orders.len(), 0);
}
#[test]
fn build_unique_requests_with_no_price() {
let mut new_orders = mock_orders();
new_orders[0].price = None;
new_orders[1].price = None;
let (_, new_orders) = build_unique_requests(&[], &new_orders);
assert_eq!(new_orders.len(), 0);
}
}
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/volume.rs | use crate::market_makers::on_ticker::{build_orders::CalculateVolumeArgs, MarketMakerOnTicker};
use fdr_common::crypto::orders::FdrOrderSide;
use rust_decimal::Decimal;
use strat_common::{
state_managers::strategy_manager::StrategyGetterTrait,
volume_strategies::{balance_weighting::calculate_balance_weight, profit_weighting::calculate_profit_weight},
};
impl<T> MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
pub(crate) fn calculate_volume(&self, args: CalculateVolumeArgs<'_>) -> Decimal {
// Calculate the balance weight, which is dependent on the current price, market balance,
// side of the order, set bid and the balance weight scalar.
let balance_weight = calculate_balance_weight(
args.price,
args.total_quote_balance,
args.total_base_balance,
args.side,
&args.market_state.config.volume_weights.balance_weight_scalar,
);
// Calculate the profit weight, which is based on the current price, side of the order,
// average cost, last price, minimum desired profit, and profit weight scalar.
let profit_weight = calculate_profit_weight(
args.price,
args.side,
args.average_cost,
args.last_price,
&self.config.desired_profit,
&args.market_state.config.volume_weights.profit_weight_scalar,
);
// Return the maximum weight between the calculated balance and profit weights.
let weight = balance_weight.max(profit_weight);
(self.config.set_bid * weight).round_dp(args.market_state.trading_pair.lot_decimals)
}
}
/// Calculates the selling volume based on the given volume and base balance.
///
/// # Arguments
///
/// * `volume` - The trading volume.
/// * `base_balance` - The available base currency balance.
///
/// # Returns
///
/// The selling volume, which is either the given volume or the base balance
/// multiplied by the reduction factor if the volume is greater than the base balance.
#[inline]
fn get_selling_volume(volume: &Decimal, base_balance: &Decimal) -> Decimal {
if volume > base_balance {
*base_balance
} else {
*volume
}
}
/// Calculates the buying volume based on the provided volume, price, and quote balance.
///
/// # Arguments
///
/// * `volume` - The volume of the asset to be bought.
/// * `price` - The price of the asset.
/// * `quote_balance` - The balance of the quote currency.
///
/// # Returns
///
/// The buying volume for the given inputs. If the cost of buying the volume exceeds the quote balance,
/// the buying volume will be reduced based on the REDUCTION_FACTOR. If the price is negative or zero,
/// the buying volume will be zero.
#[inline]
pub(crate) fn get_buying_volume(volume: &Decimal, price: &Decimal, quote_balance: &Decimal) -> Decimal {
let cost = volume * price;
if cost > *quote_balance {
if price > &Decimal::ZERO {
quote_balance / price
} else {
Decimal::ZERO
}
} else {
*volume
}
}
/// Checks the given volume against the available balance and returns
/// the adjusted volume based on the side of the order, price, and balances.
///
/// # Arguments
///
/// * `volume` - The initial volume of the order
/// * `side` - The side of the order, either `FdrOrderSide::Sell` or `FdrOrderSide::Buy`
/// * `price` - The price of the order
/// * `base_balance` - The current balance in the base currency
/// * `quote_balance` - The current balance in the quote currency
/// * `min_order` - The minimum allowed order volume
///
/// # Returns
///
/// The adjusted volume based on the given side, price, balances, and minimum order volume.
#[inline]
pub(crate) fn check_volume_against_balance(
volume: &Decimal,
side: &FdrOrderSide,
price: &Decimal,
base_balance: &Decimal,
quote_balance: &Decimal,
) -> Decimal {
match side {
FdrOrderSide::Sell => get_selling_volume(volume, base_balance),
FdrOrderSide::Buy => get_buying_volume(volume, price, quote_balance),
}
}
#[cfg(test)]
mod tests {
use super::*;
use rust_decimal_macros::dec;
#[test]
fn test_get_selling_volume() {
let volume = &dec!(5.0);
let base_balance = &dec!(10.0);
assert_eq!(get_selling_volume(volume, base_balance), dec!(5.0));
let volume = &dec!(15.0);
let base_balance = &dec!(10.0);
assert_eq!(get_selling_volume(volume, base_balance), dec!(10.0));
}
#[test]
fn test_get_buying_volume() {
let volume = &dec!(5.0);
let price = &dec!(2.0);
let quote_balance = &dec!(10.0);
assert_eq!(get_buying_volume(volume, price, quote_balance), dec!(5.0));
let volume = &dec!(6.0);
assert_eq!(get_buying_volume(volume, price, quote_balance), dec!(5));
}
#[test]
fn test_check_volume_against_balance_sell() {
let side = &FdrOrderSide::Sell;
let volume = &dec!(5.0);
let price = &dec!(2.0);
let base_balance = &dec!(10.0);
let quote_balance = &dec!(10.0);
assert_eq!(
check_volume_against_balance(volume, side, price, base_balance, quote_balance),
dec!(5.0)
);
let volume = dec!(12.0);
assert_eq!(
check_volume_against_balance(&volume, side, price, base_balance, quote_balance),
dec!(10.0)
);
}
#[test]
fn test_check_volume_against_balance_buy() {
let side = &FdrOrderSide::Buy;
let volume = &dec!(5.0);
let price = &dec!(2.0);
let base_balance = &dec!(10.0);
let quote_balance = &dec!(10.0);
assert_eq!(
check_volume_against_balance(volume, side, price, base_balance, quote_balance),
dec!(5.0)
);
let volume = &dec!(6.0);
assert_eq!(
check_volume_against_balance(volume, side, price, base_balance, quote_balance),
dec!(5)
);
}
#[test]
fn test_get_selling_volume_zero_volume() {
let volume = &dec!(0.0);
let base_balance = &dec!(10.0);
assert_eq!(get_selling_volume(volume, base_balance), dec!(0.0));
}
#[test]
fn test_get_selling_volume_zero_base_balance() {
let volume = &dec!(5.0);
let base_balance = &dec!(0.0);
assert_eq!(get_selling_volume(volume, base_balance), dec!(0.0));
}
#[test]
fn test_get_buying_volume_zero_values() {
let volume = &dec!(0.0);
let price = &dec!(2.0);
let quote_balance = &dec!(0.0);
assert_eq!(get_buying_volume(volume, price, quote_balance), dec!(0.0));
let volume = &dec!(5.0);
assert_eq!(get_buying_volume(volume, price, quote_balance), dec!(0.0));
let volume = &dec!(0.0);
let price = &dec!(0.0);
let quote_balance = &dec!(10.0);
assert_eq!(get_buying_volume(volume, price, quote_balance), dec!(0.0));
}
}
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/mod.rs | pub mod build_orders;
mod order_events;
mod price_strategy;
pub mod ticker_processing;
mod unique_orders;
pub mod volume;
use crate::error::{StrategyError, StrategyResult};
use async_trait::async_trait;
use fdr_balances::virtual_account::{pair::VirtualAccountPair, VirtualAccount};
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use slog::{debug, warn};
use std::sync::Arc;
use tokio::sync::{RwLock, RwLockReadGuard};
use tracing::{instrument, Level};
use uuid::Uuid;
use crate::market_makers::on_ticker::{
ticker_processing::{process_ticker, TickerAction},
unique_orders::build_unique_requests,
};
use fdr_common::{
crypto::{
assets::{Asset, CurrencyPair},
orders::{FdrOrderCancellationStatus, FdrOrderStatus, OrderEntry},
},
error::FdrError,
exchange::{Exchange, Market},
ticker::FdrTickerUpdate,
TradingStrategy,
};
use fdr_event::events::{FdrEvent, FdrOrderUpdate};
use fdr_store::{
core::pool::Pool,
orders::{
models::{GetOrderFilter, GetOrdersFilter, OrderDto},
OrderStore,
},
virtual_accounts::{VirtualAccountDto, VirtualAccountStore},
};
use price_guard::{PriceGuard, PriceGuardConfig};
use strat_common::{
crypto::market::{MarketState, UpdateRequest, UpdateRequests},
state_managers::{strategy_manager::StrategyGetterTrait, StateSubscriberTrait},
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MarketMakerOnTickerConfig {
pub max_orders: u32,
pub cancel_threshold: Decimal,
pub desired_profit: Decimal,
pub price_guard: PriceGuardConfig,
pub set_bid: Decimal,
pub pair: CurrencyPair,
pub exchange: Exchange,
pub strat_run_id: Uuid,
}
pub struct MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
pub(crate) config: MarketMakerOnTickerConfig,
parent_state: Arc<T>,
active: bool,
pool: Arc<Pool>,
strategy: TradingStrategy,
market: Market,
balances: VirtualAccountPair,
last_ticker: RwLock<LastTicker>,
price_guard: RwLock<PriceGuard>,
}
struct LastTicker {
last: FdrTickerUpdate,
}
impl<T> MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
pub async fn new(parent_state: Arc<T>, config: MarketMakerOnTickerConfig, pool: Arc<Pool>) -> StrategyResult<Self> {
let mut db_conn = pool.acquire().await?;
let virtual_accounts = db_conn.get_virtual_accounts(config.strat_run_id).await?;
let price_guard = RwLock::new(
PriceGuard::new(
config.price_guard.clone(),
pool.clone(),
config.strat_run_id,
config.pair,
)
.await?,
);
let quote_balance_index = get_virtual_account_index(config.pair.quote(), &virtual_accounts)?;
let base_balance_index = get_virtual_account_index(config.pair.base(), &virtual_accounts)?;
let virtual_account_pair = VirtualAccountPair::new(
VirtualAccount::new(
config.pair.base(),
virtual_accounts[base_balance_index].id,
pool.clone(),
),
VirtualAccount::new(
config.pair.quote(),
virtual_accounts[quote_balance_index].id,
pool.clone(),
),
);
Ok(MarketMakerOnTicker {
config: config.clone(),
parent_state,
pool: pool.clone(),
active: true,
strategy: TradingStrategy::MarketMakerOnTicker,
market: Market {
pair: config.pair,
exchange: config.exchange,
},
balances: virtual_account_pair,
last_ticker: RwLock::new(get_default_last_ticker(&config)),
price_guard,
})
}
#[instrument(skip(self), level = Level::DEBUG)]
async fn handle_ticker_event(&self, ticker: FdrTickerUpdate) -> StrategyResult<()> {
self.last_ticker.write().await.last = ticker;
if let Some(market_state) = self.parent_state.get_market(&self.market).await {
self._handle_ticker_event(&market_state, ticker).await?;
}
Ok(())
}
async fn _handle_ticker_event(
&self,
market_state: &RwLockReadGuard<'_, MarketState>,
ticker: FdrTickerUpdate,
) -> StrategyResult<()> {
let orders = self.get_orders().await?;
let ticker_delta_average = market_state
.moving_ticker_delta_average
.get_time_weighted_average(&ticker.timestamp);
let mut update_requests: Vec<UpdateRequest> = Vec::new();
if let Some(action) = process_ticker(
self.active,
&self.config,
&orders,
ticker_delta_average,
ticker,
market_state.last_hit,
) {
let (orders_to_cancel, orders_to_create) = match action {
TickerAction::MakeOrders => {
let proposed_orders = self.build_orders(market_state, &orders).await?;
(Vec::with_capacity(0), proposed_orders)
}
TickerAction::CancelOrders => {
let proposed_orders = self.build_orders(market_state, &[]).await?;
build_unique_requests(&orders, &proposed_orders)
}
};
if !orders_to_cancel.is_empty() {
self.cancel_existing_orders(&orders_to_cancel).await?;
for order in orders_to_cancel {
update_requests.push(UpdateRequest::Cancel(order));
}
}
if !orders_to_create.is_empty() {
self.save_new_orders(&orders_to_create).await?;
for order in orders_to_create {
update_requests.push(UpdateRequest::Order(order));
}
}
if !update_requests.is_empty() {
update_requests.push(UpdateRequest::UpdateLastHit(
self.market,
market_state.last_ticker.and_then(|ticker| ticker.last_price),
));
};
}
self.request_state_update(update_requests).await?;
Ok(())
}
async fn save_new_orders(&self, orders: &Vec<OrderEntry>) -> StrategyResult<()> {
if orders.is_empty() {
return Ok(());
}
let mut db_conn = self.pool.acquire().await?;
for order in orders {
let mut order: OrderDto = (*order).into();
order.created_at = self.last_ticker.read().await.last.timestamp;
let (_, _) = db_conn.save_order(&order, self.strategy).await?;
debug!(self.parent_state.logger(), "Placed Order: {:?}", order);
}
Ok(())
}
async fn cancel_existing_orders(&self, orders: &Vec<OrderEntry>) -> StrategyResult<()> {
if orders.is_empty() {
return Ok(());
}
let mut db_conn = self.pool.acquire().await?;
for order in orders {
if order.order_status != FdrOrderStatus::Pending && order.order_status != FdrOrderStatus::New {
let _ = db_conn
.update_order(
GetOrderFilter::Id(order.id),
None,
Some(FdrOrderCancellationStatus::Requested),
None,
None,
None,
)
.await?;
}
debug!(self.parent_state.logger(), "Requested Order Cancel: {:?}", order);
}
Ok(())
}
async fn get_orders(&self) -> StrategyResult<Vec<OrderEntry>> {
let mut db_conn = self.pool.acquire().await?;
Ok(db_conn
.get_orders(GetOrdersFilter {
pairs: None,
exchange_order_ref: None,
exchange: None,
strategies: None,
order_status: Some(vec![FdrOrderStatus::Open, FdrOrderStatus::New, FdrOrderStatus::Pending]),
cancellation_status: None,
has_volume_filled: None,
start_time: None,
end_time: None,
strat_run_id: Some(self.config.strat_run_id),
})
.await?
.into_iter()
.map(|order| order.into())
.collect())
}
#[instrument(skip(self), level = Level::DEBUG)]
async fn handle_event(&self, event: FdrEvent) -> StrategyResult<()> {
match event {
FdrEvent::Ticker(ticker) => self.handle_ticker_event(ticker).await?,
FdrEvent::Order(order) => match order {
FdrOrderUpdate::Trade(trade) => self.handle_trade(trade).await?,
FdrOrderUpdate::Error(order) => self.handle_order_error(order).await?,
_ => (),
},
_ => (),
}
Ok(())
}
}
fn get_default_last_ticker(config: &MarketMakerOnTickerConfig) -> LastTicker {
LastTicker {
last: FdrTickerUpdate {
exchange: config.exchange,
pair: config.pair,
timestamp: Default::default(),
chan_id: 0,
bid: None,
bid_size: None,
ask: None,
ask_size: None,
last_price: None,
last_price_volume: None,
low: None,
high: None,
volume: None,
low_24: None,
high_24: None,
volume_24: None,
},
}
}
#[async_trait]
impl<T> StateSubscriberTrait<Vec<UpdateRequest>, StrategyError> for MarketMakerOnTicker<T>
where
T: StrategyGetterTrait + Sync + Send,
{
async fn subscribe_to_changes(&mut self) -> StrategyResult<()> {
let mut event_receiver = self.parent_state.get_event_channel().rx();
loop {
tokio::select! {
event_res = event_receiver.recv() => {
match event_res {
Ok(event) => {
if let Err(e) = self.handle_event(event).await {
warn!(self.parent_state.logger(), "Failed to handle event: {:?}", e);
}
}
Err(e) => {
warn!(self.parent_state.logger(), "Failed to receive event: {:?}", e);
}
}
}
}
tokio::task::consume_budget().await;
}
}
#[instrument(skip(self), level = Level::DEBUG)]
async fn request_state_update(&self, update_requests: Vec<UpdateRequest>) -> StrategyResult<usize> {
let pair = &self.config.pair;
let update_requests = UpdateRequests {
pair: *pair,
requests: update_requests,
};
let sender = self.parent_state.get_request_sender();
sender
.send(update_requests)
.map_err(|_| StrategyError::FdrError(FdrError::StateUpdateMessageFailed))
}
}
fn get_virtual_account_index(asset: Asset, virtual_accounts: &[VirtualAccountDto]) -> StrategyResult<usize> {
for (i, account) in virtual_accounts.iter().enumerate() {
if account.asset == asset {
return Ok(i);
}
}
Err(StrategyError::MissingBalanceRecords)
}
| 0 |
on_ticker | /mono/crates/strategies/src/market_makers/on_ticker/ticker_processing.rs | use crate::market_makers::on_ticker::MarketMakerOnTickerConfig;
use fdr_common::{crypto::orders::OrderEntry, ticker::FdrTickerUpdate};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use tracing::{instrument, Level};
const THRESHOLD_REDUCTION: Decimal = dec!(0.80);
#[derive(Debug, PartialEq)]
pub enum TickerAction {
MakeOrders,
CancelOrders,
}
#[instrument(level = Level::DEBUG)]
#[inline]
pub(crate) fn process_ticker(
active: bool,
config: &MarketMakerOnTickerConfig,
orders: &Vec<OrderEntry>,
ticker_delta_average: Decimal,
ticker: FdrTickerUpdate,
last_hit: Option<Decimal>,
) -> Option<TickerAction> {
if !active {
return None;
}
let last_price = ticker.last_price?;
let Some(last_hit) = last_hit else {
if !orders.is_empty() {
return Some(TickerAction::CancelOrders);
}
return Some(TickerAction::MakeOrders);
};
let delta = (last_hit - last_price).abs();
let threshold = if ticker_delta_average > Decimal::ZERO {
// If we have an established ticker_delta_average, we want to use 80% of that as the threshold.
ticker_delta_average * THRESHOLD_REDUCTION
} else {
config.cancel_threshold
};
if delta >= threshold && !orders.is_empty() {
return Some(TickerAction::CancelOrders);
}
// If the number of orders is not equal to 2 times max orders, we need to place orders.
if orders.len() < (config.max_orders * 2) as usize {
return Some(TickerAction::MakeOrders);
}
None
}
#[cfg(test)]
mod tests {
use super::*;
use fdr_common::{
crypto::{
assets::{Asset, CurrencyPair},
orders::{FdrOrderSide, FdrOrderStatus},
},
exchange::{Exchange, Market},
ticker::FdrTickerUpdate,
TradingStrategy,
};
use price_guard::{static_guard::StaticPriceGuardConfig, PriceGuardConfig};
use uuid::Uuid;
fn get_config() -> MarketMakerOnTickerConfig {
let pair = CurrencyPair::new(Asset::Dot, Asset::Usd);
MarketMakerOnTickerConfig {
max_orders: 1,
cancel_threshold: dec!(0.006),
desired_profit: dec!(0.008),
price_guard: PriceGuardConfig::Static(StaticPriceGuardConfig {
min_sell_price: Default::default(),
max_buy_price: Default::default(),
}),
set_bid: dec!(50),
pair,
exchange: Exchange::Kraken,
strat_run_id: Default::default(),
}
}
fn get_last_ticker() -> FdrTickerUpdate {
FdrTickerUpdate {
exchange: Exchange::Kraken,
pair: CurrencyPair::new(Asset::Dot, Asset::Usd),
timestamp: Default::default(),
chan_id: 0,
bid: None,
bid_size: None,
ask: None,
ask_size: None,
last_price: Some(dec!(5.0)),
last_price_volume: None,
low: None,
high: None,
volume: None,
low_24: None,
high_24: None,
volume_24: None,
}
}
#[test]
fn not_active() {
let config = get_config();
let orders = Vec::with_capacity(0);
let active = false;
let last_ticker = get_last_ticker();
let resp = process_ticker(active, &config, &orders, dec!(0.1), last_ticker, None);
assert_eq!(resp, None);
}
/// This test covers the case where we already have a buy order in memory, and the new ticker price
/// is higher than the cancel threshold. We should see that the strategy will cancel the buy order.
#[test]
fn hit_cancel_threshold_above() {
let config = get_config();
let orders = vec![OrderEntry {
id: Uuid::new_v4(),
market: Market {
exchange: Exchange::Kraken,
pair: CurrencyPair::new(Asset::Dot, Asset::Usd),
},
side: FdrOrderSide::Buy,
price: Some(dec!(5.0)),
volume: Default::default(),
volume_remaining: Default::default(),
order_status: FdrOrderStatus::New,
strategy: TradingStrategy::MarketMakerOnTicker,
type_: Default::default(),
strat_run_id: None,
}];
let active = true;
let last_ticker = get_last_ticker();
let resp = process_ticker(active, &config, &orders, dec!(0.1), last_ticker, Some(dec!(5.1)));
assert_eq!(resp, Some(TickerAction::CancelOrders));
}
/// This test covers the case where we already have a buy order in memory, and the new ticker price
/// is lower than the current buy order and also surpasses the cancel threshold. We should see that
/// the strategy will cancel the buy order. NOTE: This also means part or all of the order would have
/// been filled.
#[test]
fn hit_cancel_threshold_below() {
let config = get_config();
let orders = vec![OrderEntry {
id: Uuid::new_v4(),
market: Market {
exchange: Exchange::Kraken,
pair: CurrencyPair::new(Asset::Dot, Asset::Usd),
},
side: FdrOrderSide::Buy,
price: Some(dec!(5.5)),
volume: Default::default(),
volume_remaining: Default::default(),
order_status: FdrOrderStatus::New,
strategy: TradingStrategy::MarketMakerOnTicker,
type_: Default::default(),
strat_run_id: None,
}];
let last_ticker = get_last_ticker();
let active = true;
let resp = process_ticker(active, &config, &orders, dec!(0.1), last_ticker, Some(dec!(5.1)));
assert_eq!(resp, Some(TickerAction::CancelOrders));
}
#[test]
fn test_process_ticker_no_last_price() {
let config = get_config();
let orders = vec![];
let active = true;
let mut last_ticker = get_last_ticker();
last_ticker.last_price = None;
let resp = process_ticker(active, &config, &orders, dec!(0.1), last_ticker, None);
assert_eq!(resp, None);
}
#[test]
fn test_process_ticker_no_last_hit() {
let config = get_config();
let orders = vec![];
let last_ticker = get_last_ticker();
let active = true;
let resp = process_ticker(active, &config, &orders, dec!(0.1), last_ticker, None);
assert_eq!(resp, Some(TickerAction::MakeOrders));
}
#[test]
fn test_orders_exceed_max_orders() {
let mut config = get_config();
// Set max_orders to an unrealistic low value
config.max_orders = 0;
let orders = vec![]; // Add more than 0 orders here
let active = true;
let last_ticker = get_last_ticker();
let resp = process_ticker(active, &config, &orders, dec!(0.1), last_ticker, Some(dec!(5.0)));
assert_eq!(resp, None);
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/triangular_arbitrage.rs | use async_trait::async_trait;
use fdr_balances::virtual_account::VirtualAccount;
use fdr_store::{
opportunities::{
models::{OpportunityDto, OpportunityOrderDto},
OpportunityStore,
},
orders::{models::GetOrdersFilter, OrderStore},
};
use rust_decimal::{Decimal, RoundingStrategy};
use serde::{Deserialize, Serialize};
use slog::{debug, info, warn};
use std::{collections::HashMap, default::Default, sync::Arc, time::Duration};
use uuid::Uuid;
use fdr_common::{
crypto::{
assets::{Asset, CurrencyPair},
book::Book,
orders::{FdrOrderSide, FdrOrderStatus, FdrOrderType, OrderEntry},
},
error::FdrError,
exchange::{Exchange, Market},
TradingStrategy,
};
use fdr_event::events::{AlertState, FdrEvent, FdrOrderUpdate};
use fdr_store::{core::pool::Pool, virtual_accounts::VirtualAccountStore};
use strat_common::{
crypto::market::{MarketConfig, UpdateRequest, UpdateRequests},
state_managers::{strategy_manager::StrategyGetterTrait, StateSubscriberTrait},
};
use crate::{
config::ExchangeSubscription,
error::{StrategyError, StrategyResult},
};
use super::{
opportunity::Opportunity,
order_details::OrderDetails,
path::Path,
path_step::PathStep,
throttle::{OpportunityThrottle, Throttle},
};
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TriangularArbitrageConfig {
pub strat_run_id: Uuid,
pub max_volume_btc: Decimal,
// The min diff proportional between an existing order and a potential new order
// Ex: 0.01 means the new order must be at least 1% less/greater than the existing order
pub min_order_price_difference: Decimal,
#[serde(default)]
pub dry_run: bool,
}
pub struct TriangularArbitrage<T>
where
T: StrategyGetterTrait + Sync + Send,
{
parent_state: Arc<T>,
config: TriangularArbitrageConfig,
paths: HashMap<Market, Vec<Vec<PathStep>>>,
pool: Arc<Pool>,
pub subscribed_markets: Vec<ExchangeSubscription>,
active: bool,
balances: Arc<HashMap<(Exchange, Asset), VirtualAccount>>,
throttle: OpportunityThrottle,
}
pub fn build_subscribed_markets(
markets: &HashMap<Exchange, HashMap<CurrencyPair, MarketConfig>>,
) -> Vec<ExchangeSubscription> {
markets
.iter()
.map(|(exchange, markets)| ExchangeSubscription {
exchange: *exchange,
pairs: markets.keys().cloned().collect(),
})
.collect()
}
impl<T> TriangularArbitrage<T>
where
T: StrategyGetterTrait + Sync + Send,
{
pub async fn new(parent_state: Arc<T>, config: TriangularArbitrageConfig, pool: Arc<Pool>) -> StrategyResult<Self> {
let subscribed_markets = build_subscribed_markets(parent_state.get_config_markets());
let mut paths = get_arbitrage_paths(subscribed_markets.as_slice());
set_path_pair_precision(parent_state.clone(), &mut paths).await;
// Log paths
for path in paths.values().flatten() {
info!(parent_state.logger(), "Found path: {}", Path::from(path.clone()));
}
// Get the virtual accounts
let mut db_conn = pool.acquire().await?;
let virtual_accounts = db_conn.get_virtual_accounts(config.strat_run_id).await?;
let balances = virtual_accounts
.iter()
.map(|virtual_account| {
(
(Exchange::from(virtual_account.venue), virtual_account.asset),
VirtualAccount::new(virtual_account.asset, virtual_account.id, pool.clone()),
)
})
.collect::<HashMap<(Exchange, Asset), VirtualAccount>>();
if config.dry_run {
warn!(
parent_state.logger(),
"RUNNING IN DRY-RUN MODE! NO ORDERS WILL BE CREATED!"
);
}
Ok(Self {
parent_state,
config,
paths,
pool,
subscribed_markets,
active: true,
balances: Arc::new(balances),
throttle: OpportunityThrottle::new(Duration::from_millis(500)),
})
}
pub fn handle_alert_event(&mut self, alert: AlertState) -> StrategyResult<()> {
match alert {
AlertState::Alerting => {
self.active = false;
}
AlertState::Resolved => {
self.active = true;
}
}
Ok(())
}
pub async fn handle_book_event(&mut self, market: &Market) -> StrategyResult<()> {
let Some(order_book) = self.parent_state.get_book(market).await else {
return Ok(());
};
if !order_book.top_updated {
return Ok(());
}
let Some(paths) = self.paths.get(market) else {
return Ok(());
};
let mut best_path = (Arc::new(Opportunity::default()), Decimal::ZERO);
let metrics = &self.parent_state.get_metrics_provider().arbitrage;
metrics.increment_arb_opportunity_check_count(self.config.strat_run_id, &market.exchange, &market.pair);
for path_steps in paths {
let order_details = Arc::new(self.build_order_details_vector(path_steps, *market).await?);
let order_details_count = order_details.0.len();
let is_throttled = self.throttle.is_throttled(order_details.clone());
// Difference between implied value of an asset two groups of 1 or more markets
let (post_fee_profit_rate, pre_fee_profit_rate, fee_rate_total) =
check_for_opportunity(order_details.clone());
// Increment our pre fee metric if the opp is profitable before fees
if pre_fee_profit_rate > Decimal::ONE && !is_throttled {
metrics.increment_pre_fee_opportunity(
self.parent_state.get_run_id(),
&path_steps[0].pair,
order_details_count,
);
}
// Increment our post fee metric if the opp is profitable before fees
if post_fee_profit_rate > Decimal::ONE && !is_throttled {
metrics.increment_post_fee_opportunity(
self.parent_state.get_run_id(),
&path_steps[0].pair,
order_details_count,
);
debug!(
self.parent_state.logger(),
"Discovered profitable arbitrage opportunity!";
"post_fee_profit_rate" => post_fee_profit_rate.to_string(),
"pre_fee_profit_rate" => pre_fee_profit_rate.to_string(),
"fee_rate_total" => fee_rate_total.to_string(),
"opportunity" => format!("{}", order_details),
);
}
if post_fee_profit_rate > best_path.1 {
best_path = (order_details, post_fee_profit_rate);
if post_fee_profit_rate > Decimal::ONE && !is_throttled {
metrics.increment_opportunity_supplant(self.config.strat_run_id, &market.pair, order_details_count)
}
}
}
// Throttle the opportunity to prevent double counting
self.throttle.throttle(best_path.0.clone());
if !self.config.dry_run && best_path.1 > Decimal::ONE {
if let Some(orders) = self.create_orders(best_path.0).await? {
return self.execute_opportunity(orders).await;
}
}
Ok(())
}
pub async fn build_order_details_vector(
&self,
path_steps: &Vec<PathStep>,
market: Market,
) -> StrategyResult<Opportunity> {
let mut order_details: Vec<OrderDetails> = Vec::with_capacity(3);
for path_step in path_steps {
let step_market = Market {
pair: path_step.pair,
exchange: path_step.exchange,
};
let Some(order_book) = self.parent_state.get_book(&step_market).await else {
return Ok(Opportunity::default());
};
let fee_rate = self.parent_state.get_taker_fee(&step_market).await;
if let Some(order_detail) = build_order_details(order_book, path_step, fee_rate, market != step_market) {
order_details.push(order_detail);
} else {
return Ok(Opportunity::default());
}
}
Ok(Opportunity(order_details))
}
pub async fn get_start_spend_amount(&self, action: &OrderDetails) -> StrategyResult<Decimal> {
// Get the asset we're spending
let asset = match action.path_step.side {
FdrOrderSide::Buy => action.path_step.pair.quote(),
FdrOrderSide::Sell => action.path_step.pair.base(),
};
if matches!(asset, Asset::Btc) {
return Ok(self.config.max_volume_btc);
}
let ticker_pair = get_ticker_pair(action, asset, &self.subscribed_markets)?;
let price = self
.parent_state
.get_market(&Market {
pair: ticker_pair,
exchange: action.path_step.exchange,
})
.await
.and_then(|market| market.last_ticker)
.and_then(|last_ticker| last_ticker.last_price)
.map_or_else(
|| Decimal::ZERO,
|price| calculate_spend_amount(ticker_pair, price, self.config.max_volume_btc),
);
Ok(price)
}
pub async fn create_orders(&self, opportunity: Arc<Opportunity>) -> StrategyResult<Option<Vec<OrderEntry>>> {
// check this in handle_book_event before entering instead
let action = opportunity.0.first().ok_or_else(|| StrategyError::NoOrderActions)?;
let spend_amount = self.get_start_spend_amount(action).await?;
let open_orders = self.get_orders().await?;
build_orders(
self.config.strat_run_id,
spend_amount,
opportunity,
self.balances.clone(),
&open_orders,
self.config.min_order_price_difference,
)
.await
}
async fn get_orders(&self) -> StrategyResult<Vec<OrderEntry>> {
let mut db_conn = self.pool.acquire().await?;
Ok(db_conn
.get_orders(GetOrdersFilter {
pairs: None,
exchange_order_ref: None,
exchange: None,
strategies: None,
order_status: Some(vec![FdrOrderStatus::Open, FdrOrderStatus::New, FdrOrderStatus::Pending]),
cancellation_status: None,
has_volume_filled: None,
start_time: None,
end_time: None,
strat_run_id: Some(self.config.strat_run_id),
})
.await?
.into_iter()
.map(|order| order.into())
.collect())
}
async fn execute_opportunity(&self, orders: Vec<OrderEntry>) -> StrategyResult<()> {
let mut db_conn = self.pool.acquire().await?;
for order in orders.iter() {
let order_dto = (*order).into();
let (_, _) = db_conn
.save_order(&order_dto, TradingStrategy::TriangularArbitrage)
.await?;
}
let requests: Vec<UpdateRequest> = orders.iter().map(|order| UpdateRequest::Order(*order)).collect();
self.request_state_update(requests).await?;
// A bit of a hack to ensure we don't spam orders on the same opportunity
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
self.store_opportunity(orders).await?;
Ok(())
}
pub async fn store_opportunity(&self, orders: Vec<OrderEntry>) -> StrategyResult<usize> {
let mut db_conn = self.pool.acquire().await?;
let uuid = Uuid::new_v4();
db_conn
.save_opportunity(OpportunityDto {
id: uuid,
run_id: self.parent_state.get_run_id(),
})
.await?;
for order in orders {
db_conn
.save_opportunity_order(OpportunityOrderDto {
opportunity_id: uuid,
order_id: order.id,
})
.await?;
}
Ok(usize::default())
}
}
pub async fn handle_event(
event: FdrEvent,
balances: Arc<HashMap<(Exchange, Asset), VirtualAccount>>,
) -> StrategyResult<()> {
if let FdrEvent::Order(FdrOrderUpdate::Trade(trade)) = event {
if let Some(quote_balance) = balances.get(&(trade.market.exchange, trade.market.pair.quote())) {
quote_balance.update_balance_on_trade(&trade, None).await?;
}
if let Some(base_balance) = balances.get(&(trade.market.exchange, trade.market.pair.base())) {
base_balance.update_balance_on_trade(&trade, None).await?;
}
}
Ok(())
}
pub async fn set_path_pair_precision<T>(parent_state: Arc<T>, paths: &mut HashMap<Market, Vec<Vec<PathStep>>>)
where
T: StrategyGetterTrait + Sync + Send,
{
for (_, pair_paths) in paths.iter_mut() {
for path_steps in pair_paths.iter_mut() {
for step in path_steps.iter_mut() {
let Some(trading_pair) = parent_state
.get_market(&Market {
pair: step.pair,
exchange: step.exchange,
})
.await
.map(|market| market.trading_pair)
else {
continue;
};
step.volume_precision = Some(trading_pair.lot_decimals);
step.price_precision = Some(trading_pair.pair_decimals);
}
let path_steps_clone = path_steps.clone();
for step in path_steps.iter_mut() {
for other_step in path_steps_clone.iter() {
if step.pair == other_step.pair {
continue;
}
if step.pair.base() == other_step.pair.base()
&& (step.volume_precision.is_none() || step.volume_precision > other_step.volume_precision)
{
step.volume_precision = other_step.volume_precision;
}
}
}
}
}
}
pub async fn build_orders(
strat_run_id: Uuid,
spend_amount: Decimal,
actions: Arc<Opportunity>,
balances: Arc<HashMap<(Exchange, Asset), VirtualAccount>>,
open_orders: &Vec<OrderEntry>,
min_order_price_difference: Decimal,
) -> StrategyResult<Option<Vec<OrderEntry>>> {
let mut orders = Vec::with_capacity(3);
let mut spend_amount = spend_amount;
for action in actions.0.as_slice() {
let Some((price, _)) = action.book_order else {
return Ok(None);
};
for order in open_orders {
let Some(open_order_price) = order.price else {
continue;
};
let absolute_difference = (open_order_price - price).abs();
let Some(proportional_difference) = absolute_difference.checked_div(price) else {
continue;
};
if proportional_difference < min_order_price_difference {
return Ok(None);
}
}
let (volume, next_spend_amount, spend_asset, exchange) = match action.path_step.side {
FdrOrderSide::Buy => (
spend_amount / price,
spend_amount / price,
action.path_step.pair.quote(),
action.path_step.exchange,
),
FdrOrderSide::Sell => (
spend_amount,
spend_amount * price,
action.path_step.pair.base(),
action.path_step.exchange,
),
};
let Some(volume_precision) = action.path_step.volume_precision else {
return Ok(None);
};
let volume = volume.round_dp_with_strategy(volume_precision, RoundingStrategy::MidpointNearestEven);
let Some(price_precision) = action.path_step.price_precision else {
return Ok(None);
};
let price = price.round_dp_with_strategy(price_precision, RoundingStrategy::MidpointNearestEven);
if price.le(&Decimal::ZERO)
|| volume.le(&Decimal::ZERO)
|| spend_amount.le(&Decimal::ZERO)
|| if let Some(balance) = balances.get(&(exchange, spend_asset)) {
!has_available_balance(
spend_amount,
Market {
pair: action.path_step.pair,
exchange: action.path_step.exchange,
},
action.path_step.side,
open_orders,
balance,
)
.await?
} else {
false
}
{
return Ok(None);
}
spend_amount = next_spend_amount;
orders.push(OrderEntry {
id: Uuid::new_v4(),
market: Market {
exchange: action.path_step.exchange,
pair: action.path_step.pair,
},
side: action.path_step.side,
volume,
volume_remaining: volume,
price: Some(price),
order_status: FdrOrderStatus::New,
strategy: TradingStrategy::TriangularArbitrage,
type_: FdrOrderType::Limit,
strat_run_id: Some(strat_run_id),
});
}
Ok(Some(orders))
}
pub async fn has_available_balance(
spend_amount: Decimal,
market: Market,
side: FdrOrderSide,
open_orders: &[OrderEntry],
balance: &VirtualAccount,
) -> StrategyResult<bool> {
let mut locked_balance = Decimal::ZERO;
open_orders.iter().for_each(|open_order| {
if open_order.market == market && open_order.side == side {
if let Some((_, locked_amount)) = open_order.get_locked_balance() {
locked_balance += locked_amount;
}
}
});
Ok((balance.balance().await? - locked_balance) > spend_amount)
}
pub fn calculate_spend_amount(ticker_pair: CurrencyPair, price: Decimal, max_volume_btc: Decimal) -> Decimal {
match ticker_pair.quote() == Asset::Btc {
true => max_volume_btc / price,
false => max_volume_btc * price,
}
}
pub fn get_ticker_pair(
action: &OrderDetails,
asset: Asset,
subscriptions: &[ExchangeSubscription],
) -> StrategyResult<CurrencyPair> {
action
.path_step
.pair
.has_asset(Asset::Btc)
.then_some(action.path_step.pair)
.or_else(|| {
if let Some(subscription) = subscriptions
.iter()
.find(|subscription| subscription.exchange == action.path_step.exchange)
{
subscription
.pairs
.iter()
.find(|pair| pair.has_assets(asset, Asset::Btc))
.cloned()
} else {
None
}
})
.ok_or_else(|| StrategyError::MissingBtcPair(asset))
}
pub fn check_for_opportunity(opp: Arc<Opportunity>) -> (Decimal, Decimal, Decimal) {
match opp.0.len() {
3 => check_triangular_opportunity(opp),
2 => check_binary_opportunity(opp),
_ => (Decimal::ZERO, Decimal::ZERO, Decimal::ZERO),
}
}
pub fn check_binary_opportunity(opp: Arc<Opportunity>) -> (Decimal, Decimal, Decimal) {
let (Some(zeroth), Some(first)) = (opp.0.first(), opp.0.last()) else {
return (Decimal::ZERO, Decimal::ZERO, Decimal::ZERO);
};
// TODO: Determine how we factor rebalancing fees into profitability calculation
// trades that rebalance us can be considered more profitable
let pre_fee_profitability = zeroth.book_top_rate / first.book_top_rate;
let fee_rate_total = zeroth.fee_rate + first.fee_rate;
let post_fee_profitability = pre_fee_profitability * (Decimal::ONE - fee_rate_total);
(post_fee_profitability, pre_fee_profitability, fee_rate_total)
}
pub fn check_triangular_opportunity(opp: Arc<Opportunity>) -> (Decimal, Decimal, Decimal) {
let (Some(zeroth), Some(first), Some(second)) = (opp.0.first(), opp.0.get(1), opp.0.get(2)) else {
return (Decimal::ZERO, Decimal::ZERO, Decimal::ZERO);
};
// TODO: Determine how we factor rebalancing fees into profitability calculation for x-exchange
let pre_fee_profitability: Decimal = zeroth.book_top_rate / first.book_top_rate / second.book_top_rate;
let fee_rate_total: Decimal = zeroth.fee_rate + first.fee_rate + second.fee_rate;
let post_fee_profitability = pre_fee_profitability * (Decimal::ONE - fee_rate_total);
(post_fee_profitability, pre_fee_profitability, fee_rate_total)
}
pub fn get_book_top_rate(price: &Decimal, side: FdrOrderSide, input_asset_terms: bool) -> Option<Decimal> {
match side {
FdrOrderSide::Buy => input_asset_terms
.then_some(*price)
.or_else(|| Some(Decimal::ONE / price)),
FdrOrderSide::Sell => input_asset_terms.then(|| Decimal::ONE / price).or(Some(*price)),
}
}
pub fn build_order_details(
order_book: Book,
path_step: &PathStep,
fee_rate: Decimal,
input_asset_terms: bool,
) -> Option<OrderDetails> {
let book_order = (match path_step.side {
FdrOrderSide::Buy => order_book.lowest_ask(),
FdrOrderSide::Sell => order_book.highest_bid(),
})?;
let rate = get_book_top_rate(&book_order.0, path_step.side, input_asset_terms)?;
Some(OrderDetails {
book_top_rate: rate,
book_order: Some(book_order),
fee_rate,
path_step: *path_step,
})
}
pub fn get_arbitrage_paths(pairs: &[ExchangeSubscription]) -> HashMap<Market, Vec<Vec<PathStep>>> {
let pairs: Vec<Market> = pairs
.iter()
.flat_map(|subscription| {
subscription.pairs.iter().map(move |pair| Market {
pair: *pair,
exchange: subscription.exchange,
})
})
.collect();
pairs
.iter()
.filter_map(|start_market| {
let base = &start_market.pair.base();
let quote = &start_market.pair.quote();
let paths: Vec<Vec<PathStep>> = pairs
.iter()
.filter_map(|next_market| {
if next_market == start_market {
return None;
}
let triangular_path_steps = {
if next_market.pair.has_asset(*base) {
get_path_steps(base, quote, start_market, next_market, &pairs)
} else if next_market.pair.has_asset(*quote) {
get_path_steps(quote, base, start_market, next_market, &pairs)
} else {
vec![]
}
};
let binary_path_steps = match next_market.pair == start_market.pair {
true => vec![
build_binary_arbitrage_steps(*start_market, *next_market),
build_binary_arbitrage_steps(*next_market, *start_market),
],
false => vec![],
};
let path_steps: Vec<Vec<PathStep>> = triangular_path_steps
.iter()
.chain(&binary_path_steps)
.cloned()
.collect();
if path_steps.is_empty() {
None
} else {
Some(path_steps)
}
})
.flatten()
.collect();
(!paths.is_empty()).then_some((*start_market, paths))
})
.collect()
}
pub fn build_binary_arbitrage_steps(start_market: Market, end_market: Market) -> Vec<PathStep> {
vec![
PathStep {
side: FdrOrderSide::Buy,
pair: start_market.pair,
volume_precision: None,
price_precision: None,
exchange: start_market.exchange,
},
PathStep {
side: FdrOrderSide::Sell,
pair: end_market.pair,
volume_precision: None,
price_precision: None,
exchange: end_market.exchange,
},
]
}
pub fn get_path_steps(
start_asset: &Asset,
end_asset: &Asset,
start_market: &Market,
next_market: &Market,
pairs: &[Market],
) -> Vec<Vec<PathStep>> {
let next_asset = if start_asset == &next_market.pair.base() {
next_market.pair.quote()
} else {
next_market.pair.base()
};
pairs
.iter()
.filter(|&&market| market.pair.has_assets(next_asset, *end_asset))
.map(|last_market| {
vec![
build_order_step(
*start_asset,
start_market.pair,
FdrOrderSide::Buy,
start_market.exchange,
),
build_order_step(*start_asset, next_market.pair, FdrOrderSide::Sell, next_market.exchange),
build_order_step(*end_asset, last_market.pair, FdrOrderSide::Buy, last_market.exchange),
]
})
.collect()
}
pub fn build_order_step(asset: Asset, pair: CurrencyPair, match_side: FdrOrderSide, exchange: Exchange) -> PathStep {
PathStep {
side: if asset == pair.base() {
match_side
} else if FdrOrderSide::Buy == match_side {
FdrOrderSide::Sell
} else {
FdrOrderSide::Buy
},
pair,
volume_precision: None,
price_precision: None,
exchange,
}
}
#[async_trait]
impl<T> StateSubscriberTrait<Vec<UpdateRequest>, StrategyError> for TriangularArbitrage<T>
where
T: StrategyGetterTrait + Sync + Send,
{
async fn subscribe_to_changes(&mut self) -> StrategyResult<()> {
let mut book_receivers = Vec::with_capacity(self.subscribed_markets.len());
let event_receiver = self.parent_state.get_event_channel();
let balances = self.balances.clone();
let logger = self.parent_state.logger().clone();
tokio::task::spawn(async move {
let mut event_receiver = event_receiver.rx();
loop {
tokio::select! {
event_res = event_receiver.recv() => {
match event_res {
Ok(event) => {
if let Err(e) = handle_event(event, balances.clone()).await {
warn!(logger.clone(), "Failed to handle event: {:?}", e);
}
}
Err(e) => {
warn!(logger.clone(), "Failed to receive event: {:?}", e);
}
}
}
}
}
});
// we are only interested in markets involved in PathSteps. Other subscribed keys don't have any
// impact on the strategy as there are no triangles they can be a part of
let parent_state_clone = self.parent_state.clone();
let paths_clone = self.paths.clone();
for (market, _) in paths_clone.iter() {
if let Some(book_receiver) = parent_state_clone.get_book_receiver(market) {
book_receivers.push((market, book_receiver));
}
}
loop {
for (_, (market, receiver)) in &mut book_receivers.iter_mut().enumerate() {
match receiver.has_changed() {
Ok(true) => {
if let Err(e) = self.handle_book_event(market).await {
warn!(self.parent_state.logger(), "Failed to handle book event: {:?}", e);
}
let _ = receiver.changed().await;
}
Ok(false) => {
continue;
}
Err(e) => {
warn!(self.parent_state.logger(), "Failed to handle book event: {:?}", e);
continue;
}
};
}
tokio::time::sleep(std::time::Duration::from_millis(1)).await;
}
}
async fn request_state_update(&self, update_requests: Vec<UpdateRequest>) -> StrategyResult<usize> {
let sender = self.parent_state.get_request_sender();
let update_requests = UpdateRequests {
requests: update_requests,
// Dummy pair as it isn't directly used in arb.
pair: CurrencyPair::new(Asset::Btc, Asset::Usd),
};
sender
.send(update_requests)
.map_err(|_| StrategyError::FdrError(FdrError::StateUpdateMessageFailed))
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/order_details.rs | use std::fmt::{Display, Formatter};
use fdr_common::{Price, Volume};
use rust_decimal::Decimal;
use super::path_step::PathStep;
#[derive(Debug, PartialEq, Clone, Hash, Eq)]
pub struct OrderDetails {
pub book_top_rate: Decimal,
pub book_order: Option<(Price, Volume)>,
pub fee_rate: Decimal,
pub path_step: PathStep,
}
impl Display for OrderDetails {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if let Some(book_order) = self.book_order {
write!(
f,
"{} {} {} @ {}",
self.path_step.side, self.path_step.pair, book_order.1, book_order.0
)
} else {
write!(f, "N/A")
}
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/opportunity.rs | use std::fmt::{Display, Formatter};
use super::order_details::OrderDetails;
#[derive(Default, Debug, PartialEq, Hash, Eq)]
pub struct Opportunity(pub Vec<OrderDetails>);
impl Opportunity {
pub fn len(self) -> usize {
self.0.len()
}
pub fn is_empty(self) -> bool {
self.0.is_empty()
}
}
impl Display for Opportunity {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
for (index, val) in self.0.iter().enumerate() {
write!(
f,
"{}{}",
val,
match index == self.0.len() - 1 {
true => "",
false => " -> ",
}
)?;
}
Ok(())
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/path.rs | use std::fmt::{Display, Error, Formatter};
use fdr_common::crypto::assets::CurrencyPair;
use super::path_step::PathStep;
/// A `Path` represents a series of steps that result in an arbitrage execution. A `Path` does not garauntee an
/// opportunity but can be folled to determine if there is a valid opportunity.
#[derive(Debug)]
pub struct Path(Vec<PathStep>);
// TODO: Replace the use of `Vec<PathStep>` with `Path` so we can implement custom helper methods and traits on paths.
impl Path {
pub fn pairs(&self) -> impl Iterator<Item = CurrencyPair> + '_ {
self.0.iter().map(|step| step.pair)
}
}
impl Display for Path {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
write!(
f,
"{}",
self.0
.iter()
.map(|step| step.to_string())
.collect::<Vec<_>>()
.join(", ")
)
}
}
/// Anything that can be turned into an iterator of `PathStep` can be considered a `Path`. This allows us to use `Map`
/// iterators without needing to repeatedly collect into a vector.
impl<T: IntoIterator<Item = PathStep>> From<T> for Path {
fn from(value: T) -> Self {
Path(value.into_iter().collect())
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/mod.rs | pub mod tests;
pub mod triangular_arbitrage;
pub mod opportunity;
pub mod order_details;
pub mod path;
pub mod path_step;
mod throttle;
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/tests.rs | #[cfg(test)]
mod test {
use std::{collections::HashMap, sync::Arc};
use fdr_common::{
crypto::{
assets::{Asset, CurrencyPair},
book::Book,
orders::FdrOrderSide,
},
exchange::Exchange,
Price, Volume,
};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use strat_common::crypto::market::{
ticker_delta::{TickerDeltaCoefficientConfig, TickerDeltaConfig},
MarketConfig, VolumeWeightConfig,
};
use crate::{
arbitrage::{
opportunity::Opportunity,
order_details::OrderDetails,
path_step::PathStep,
triangular_arbitrage::{
build_order_details, build_order_step, build_subscribed_markets, calculate_spend_amount,
check_for_opportunity, get_arbitrage_paths, get_book_top_rate, get_ticker_pair,
},
},
config::ExchangeSubscription,
};
#[test]
fn test_build_subscribed_markets() {
let mut markets: HashMap<Exchange, HashMap<CurrencyPair, MarketConfig>> = HashMap::new();
let mut market: HashMap<CurrencyPair, MarketConfig> = HashMap::new();
market.insert(
CurrencyPair::new(Asset::Btc, Asset::Usd),
MarketConfig {
ticker_delta: TickerDeltaConfig {
decay_factor: 0.001,
ticker_start_time: None,
coefficient: TickerDeltaCoefficientConfig {
time_window: 60,
increase_by: dec!(0.05),
},
},
volume_weights: VolumeWeightConfig {
profit_weight_scalar: dec!(3),
balance_weight_scalar: dec!(6),
},
},
);
market.insert(
CurrencyPair::new(Asset::Btc, Asset::Eth),
MarketConfig {
ticker_delta: TickerDeltaConfig {
decay_factor: 0.001,
ticker_start_time: None,
coefficient: TickerDeltaCoefficientConfig {
time_window: 60,
increase_by: dec!(0.05),
},
},
volume_weights: VolumeWeightConfig {
profit_weight_scalar: dec!(3),
balance_weight_scalar: dec!(6),
},
},
);
markets.insert(Exchange::Kraken, market.clone());
markets.insert(Exchange::Poloniex, market);
let subscribed_markets = build_subscribed_markets(&markets);
assert!(subscribed_markets.len() == 2);
}
#[test]
fn test_get_arbitrage_paths() {
let subscriptions = vec![
ExchangeSubscription {
exchange: Exchange::Kraken,
pairs: vec![
CurrencyPair::new(Asset::Btc, Asset::Usd),
CurrencyPair::new(Asset::Btc, Asset::Cad),
CurrencyPair::new(Asset::Usd, Asset::Cad),
]
.into_iter()
.collect(),
},
ExchangeSubscription {
exchange: Exchange::Poloniex,
pairs: vec![CurrencyPair::new(Asset::Btc, Asset::Usd)].into_iter().collect(),
},
];
let expected_market_count = subscriptions
.iter()
.fold(0, |count, subscription| count + subscription.pairs.len());
let paths = get_arbitrage_paths(subscriptions.as_slice());
assert_eq!(paths.len(), expected_market_count);
}
#[test]
fn test_get_book_top_rate() {
let price = Decimal::new(100, 2);
let rate_buy_1 = get_book_top_rate(&price, FdrOrderSide::Buy, true);
let rate_buy_2 = get_book_top_rate(&price, FdrOrderSide::Buy, false);
let rate_sell_1 = get_book_top_rate(&price, FdrOrderSide::Sell, true);
let rate_sell_2 = get_book_top_rate(&price, FdrOrderSide::Sell, false);
assert_eq!(rate_buy_1, Some(price));
assert_eq!(rate_buy_2, Some(Decimal::ONE / price));
assert_eq!(rate_sell_1, Some(Decimal::ONE / price));
assert_eq!(rate_sell_2, Some(price));
}
#[test]
fn test_build_order_step() {
let pair = CurrencyPair::new(Asset::Btc, Asset::Usd);
let order_step_buy_1 = build_order_step(Asset::Btc, pair, FdrOrderSide::Buy, Exchange::Kraken);
let order_step_buy_2 = build_order_step(Asset::Usd, pair, FdrOrderSide::Buy, Exchange::Kraken);
let order_step_sell_1 = build_order_step(Asset::Btc, pair, FdrOrderSide::Sell, Exchange::Kraken);
let order_step_sell_2 = build_order_step(Asset::Usd, pair, FdrOrderSide::Sell, Exchange::Kraken);
assert_eq!(order_step_buy_1.side, FdrOrderSide::Buy);
assert_eq!(order_step_buy_2.side, FdrOrderSide::Sell);
assert_eq!(order_step_sell_1.side, FdrOrderSide::Sell);
assert_eq!(order_step_sell_2.side, FdrOrderSide::Buy);
}
#[test]
fn test_build_order_details() {
let mut book = Book::new(10);
book.bids.insert(Price::from(100), Volume::from(1));
book.asks.insert(Price::from(200), Volume::from(1));
let path_step = PathStep {
exchange: Exchange::Kraken,
pair: CurrencyPair::new(Asset::Btc, Asset::Usd),
side: FdrOrderSide::Buy,
volume_precision: None,
price_precision: None,
};
let fee_rate = Decimal::new(20, 4);
let order_details = build_order_details(book, &path_step, fee_rate, true);
assert_ne!(order_details, None);
}
#[test]
fn test_check_for_opportunity() {
let order_details = vec![
OrderDetails {
book_top_rate: dec!(0.0002627989666744630360113424),
book_order: Some((dec!(3805.19), dec!(3.046471))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Buy,
pair: CurrencyPair::new(Asset::Eth, Asset::Usdt),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
},
OrderDetails {
book_top_rate: dec!(0.0000341879056181327181333677),
book_order: Some((dec!(29250.11), dec!(0.105554))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Sell,
pair: CurrencyPair::new(Asset::Eth, Asset::Trx),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
},
OrderDetails {
book_top_rate: dec!(7.7942322681215900233826968044),
book_order: Some((dec!(0.1283), dec!(3561.565))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Sell,
pair: CurrencyPair::new(Asset::Trx, Asset::Usdt),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
},
];
let (opportunity, _, _) = check_for_opportunity(Arc::new(Opportunity(order_details.clone())));
let mut profitable_orders = vec![OrderDetails {
book_top_rate: dec!(0.0004627989666744630360113424),
book_order: Some((dec!(2000), dec!(3.046471))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Buy,
pair: CurrencyPair::new(Asset::Eth, Asset::Usdt),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
}];
let other_orders = order_details[order_details.len() - 2..].to_vec();
profitable_orders.extend(other_orders);
let (profitable_opportunity, _, _) = check_for_opportunity(Arc::new(Opportunity(profitable_orders)));
assert!(opportunity < Decimal::ONE);
assert!(profitable_opportunity > Decimal::ZERO);
}
#[test]
fn test_check_for_opportunity_tri_vs_bi() {
let order_details = vec![
OrderDetails {
book_top_rate: get_book_top_rate(&dec!(100), FdrOrderSide::Buy, false).unwrap(),
book_order: Some((dec!(100), dec!(1))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Buy,
pair: CurrencyPair::new(Asset::Btc, Asset::Usd),
volume_precision: None,
price_precision: None,
exchange: Exchange::Kraken,
},
},
OrderDetails {
book_top_rate: get_book_top_rate(&dec!(150), FdrOrderSide::Sell, true).unwrap(),
book_order: Some((dec!(150), dec!(1))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Sell,
pair: CurrencyPair::new(Asset::Btc, Asset::Cad),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
},
OrderDetails {
book_top_rate: get_book_top_rate(&dec!(1.35), FdrOrderSide::Buy, true).unwrap(),
book_order: Some((dec!(1.35), dec!(100))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Buy,
pair: CurrencyPair::new(Asset::Usd, Asset::Cad),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
},
];
// Should make $15 CAD or 10% profit
let (tri_opportunity, _, _) = check_for_opportunity(Arc::new(Opportunity(order_details)));
let order_details = vec![
OrderDetails {
book_top_rate: get_book_top_rate(&dec!(100), FdrOrderSide::Buy, false).unwrap(),
book_order: Some((dec!(100), dec!(1))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Buy,
pair: CurrencyPair::new(Asset::Btc, Asset::Usd),
volume_precision: None,
price_precision: None,
exchange: Exchange::Kraken,
},
},
OrderDetails {
book_top_rate: get_book_top_rate(&dec!(120), FdrOrderSide::Sell, true).unwrap(),
book_order: Some((dec!(120), dec!(1))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Sell,
pair: CurrencyPair::new(Asset::Btc, Asset::Usd),
volume_precision: None,
price_precision: None,
exchange: Exchange::Kraken,
},
},
];
// Should make $20 USD or 20% profit
let (bi_opportunity, _, _) = check_for_opportunity(Arc::new(Opportunity(order_details)));
assert!(bi_opportunity > tri_opportunity);
}
#[test]
fn test_get_ticker_pair() {
let action = OrderDetails {
book_top_rate: dec!(0.0002627989666744630360113424),
book_order: Some((dec!(3805.19), dec!(3.046471))),
fee_rate: Decimal::ZERO,
path_step: PathStep {
side: FdrOrderSide::Buy,
pair: CurrencyPair::new(Asset::Eth, Asset::Usdt),
volume_precision: None,
price_precision: None,
exchange: Exchange::Poloniex,
},
};
let subscriptions = vec![ExchangeSubscription {
exchange: Exchange::Poloniex,
pairs: vec![CurrencyPair::new(Asset::Eth, Asset::Btc)].into_iter().collect(),
}];
let ticker_pair = get_ticker_pair(&action, Asset::Eth, &subscriptions).ok();
assert_eq!(ticker_pair, Some(CurrencyPair::new(Asset::Eth, Asset::Btc)));
}
#[test]
fn test_calculate_spend_amount() {
let max_volume_btc = dec!(1.0);
let price_usd = dec!(100000.0);
let spend_amount = calculate_spend_amount(CurrencyPair::new(Asset::Btc, Asset::Usd), price_usd, max_volume_btc);
let price_eth = dec!(0.05);
let spend_amount_2 =
calculate_spend_amount(CurrencyPair::new(Asset::Eth, Asset::Btc), price_eth, max_volume_btc);
assert_eq!(spend_amount, max_volume_btc * price_usd);
assert_eq!(spend_amount_2, max_volume_btc / price_eth);
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/path_step.rs | use std::fmt::{Display, Error, Formatter};
use fdr_common::{
crypto::{assets::CurrencyPair, orders::FdrOrderSide},
exchange::Exchange,
};
#[derive(Debug, PartialEq, Clone, Copy, Hash, Eq)]
pub struct PathStep {
pub side: FdrOrderSide,
pub pair: CurrencyPair,
pub volume_precision: Option<u32>,
pub price_precision: Option<u32>,
pub exchange: Exchange,
}
impl Display for PathStep {
fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
match self.side {
FdrOrderSide::Sell => {
write!(f, "sell {} to receive {}", self.pair.base(), self.pair.quote())
}
FdrOrderSide::Buy => {
write!(f, "spend {} to buy {}", self.pair.quote(), self.pair.base())
}
}
}
}
| 0 |
arbitrage | /mono/crates/strategies/src/arbitrage/throttle.rs | use super::opportunity::Opportunity;
use std::{
collections::HashMap,
hash::{Hash, Hasher},
sync::Arc,
time::{Duration, Instant},
};
const DEFAULT_CAPACITY: usize = 1000;
/// A throttle is anything acting on a type T that can determine whether an instance of T is throttled, and track
/// throttling values.
pub(crate) trait Throttle<T> {
fn is_throttled(&self, val: T) -> bool;
fn throttle(&mut self, val: T);
}
/// OpportunityThrottleKey allows us to define a custom hash function to hash our opportunities on. This gives us
/// flexibility to change how we hash opps in the future.
#[derive(PartialEq, Eq)]
struct OpportunityThrottleKey(Arc<Opportunity>);
impl Hash for OpportunityThrottleKey {
fn hash<H: Hasher>(&self, state: &mut H) {
for details in &self.0.as_ref().0 {
if let Some((price, _)) = details.book_order {
price.hash(state);
}
details.path_step.exchange.hash(state);
details.path_step.pair.hash(state);
details.path_step.side.hash(state);
}
}
}
/// Tracks the last time an opp was throttled and can answer whether an opp is currently throttled.
pub(crate) struct OpportunityThrottle {
cache: HashMap<OpportunityThrottleKey, Instant>,
threshold: Duration,
capacity: usize,
}
impl OpportunityThrottle {
#[allow(dead_code)]
pub fn new(threshold: Duration) -> Self {
Self {
cache: HashMap::with_capacity(DEFAULT_CAPACITY),
threshold,
capacity: DEFAULT_CAPACITY,
}
}
}
impl Throttle<Arc<Opportunity>> for OpportunityThrottle {
fn is_throttled(&self, opp: Arc<Opportunity>) -> bool {
self.cache
.get(&OpportunityThrottleKey(opp))
.map_or(false, |last_time| last_time.elapsed() > self.threshold)
}
/// Throttle records the current instant that an opportunity has been throttled and cleans up the cache if the cache
/// is greater than the capacity. If the cache is still large (> 1/2 capacity) after cleaning it means that we are
/// experiencing a seeing a lot of opportunities and the cache is doubled in size. The capacity will grow naturally
/// until cleaning the cache recovers more than 1/2 capcity. This is done to reduce the frequency the cache needs to
/// be cleaned because cleaning is costly (requires iterating the entire cache)
fn throttle(&mut self, opp: Arc<Opportunity>) {
let now = Instant::now();
self.cache.insert(OpportunityThrottleKey(opp), now);
// If our map exceeds our capacity remove all of the elements that are older than our threshold
if self.cache.len() > self.capacity {
self.cache.retain(|_, last_time| last_time.elapsed() > self.threshold)
}
// If our cache is still greater than 1/2 capacity double our capacity to minimize cache pruning
if self.cache.len() > self.capacity / 2 {
self.cache.reserve(self.capacity);
self.capacity *= 2
}
}
}
| 0 |
back_testing_config_generator | /mono/crates/back_testing_config_generator/Cargo.toml | [package]
name = "config-generator"
version.workspace = true
edition.workspace = true
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[[bin]]
name = "generator"
path = "src/bin/mod.rs"
[dependencies]
fdr-common = { path = "../fdr_common", features = ["tracing"] }
fdr-http = { path = "../fdr_http" }
fdr-store = { path = "../fdr_store" }
strat-common = { path = "../strat_common" }
strategy-manager = { path = "../strategy_manager" }
strategies = { path = "../strategies" }
fdr-balances = { path = "../fdr_balances" }
price_guard = { path = "../price_guard" }
serde = { workspace = true, features = ["derive"] }
serde_json = { workspace = true }
uuid = { workspace = true }
tokio = { workspace = true }
anyhow = { workspace = true }
rust_decimal = { workspace = true }
derive_more = { workspace = true }
toml = { workspace = true }
chrono = { workspace = true }
serde_yaml = "0.9.31"
rand = "0.8.5"
thiserror = { workspace = true } | 0 |
src | /mono/crates/back_testing_config_generator/src/lib.rs | use thiserror::Error;
pub mod config;
pub mod tilt;
#[derive(Error, Debug)]
pub enum BackTestGeneratorError {
#[error(transparent)]
RustDecimal(#[from] rust_decimal::Error),
#[error(transparent)]
Io(#[from] std::io::Error),
#[error(transparent)]
SerdeYaml(#[from] serde_yaml::Error),
#[error(transparent)]
Toml(#[from] toml::ser::Error),
}
pub type BackTestGeneratorResult<T, E = BackTestGeneratorError> = Result<T, E>;
| 0 |
bin | /mono/crates/back_testing_config_generator/src/bin/mod.rs | use config_generator::{
config::{ArchiveConfig, BackTestConfig, BalanceConfig, Fees, StateStrategy, TickerDataConfig},
tilt::{K8SResource, K8SYaml, Labels, TiltFile},
BackTestGeneratorResult,
};
use fdr_common::{
config::{MetricsConfig, ServerConfig},
crypto::assets::{Asset, CurrencyPair},
exchange::Exchange,
tracing::config::TracingConfig,
utils::cli::{Args, Parser},
TradingStrategy,
};
use fdr_store::config::PostgresConfig;
use price_guard::PriceGuardConfig;
use rand::Rng;
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use std::{
collections::{HashMap, HashSet},
env,
};
use strat_common::crypto::market::{
ticker_delta::{TickerDeltaCoefficientConfig, TickerDeltaConfig},
MarketConfig, VolumeWeightConfig,
};
use strategies::{config::StrategyConfigKind, market_makers::on_ticker::MarketMakerOnTickerConfig};
use strategy_manager::config::{NotifySubscribersConfig, StrategyManagerConfig};
use tokio::fs;
use uuid::Uuid;
#[derive(Debug, Clone, Deserialize)]
struct BackTestGeneratorConfig {
pub num_of_back_tests: u32,
pub pair: CurrencyPair,
pub strategy_type: TradingStrategy,
pub metrics: MetricsConfig,
pub server: ServerConfig,
pub tracing: TracingConfig,
pub notify_subscribers: NotifySubscribersConfig,
pub postgres: PostgresConfig,
pub balances: Vec<BalanceConfig>,
pub fees: Vec<Fees>,
pub cancel_threshold: MinMax,
pub set_bid: MinMax,
pub desired_profit: MinMax,
pub profit_weight: MinMax,
pub balance_weight: MinMax,
pub ticker_delta_increase: MinMax,
pub ticker_delta_coefficient_time_min: i64,
pub ticker_delta_coefficient_time_max: i64,
pub ticker_data_config: TickerDataConfig,
pub price_guard: PriceGuardConfig,
pub state_strategy: StateStrategy,
}
#[derive(Debug, Clone, Deserialize)]
pub struct MinMax {
min: f32,
max: f32,
}
struct BackTestConfigGenerator {
config: BackTestGeneratorConfig,
}
const DIRECTORY_PATH: &str = "helm/back-testing-service";
impl BackTestConfigGenerator {
pub fn new(config: BackTestGeneratorConfig) -> Self {
Self { config }
}
pub async fn generate_charts(&self) -> BackTestGeneratorResult<()> {
let random_market_configs = self.generate_market_configs()?;
let path = env::current_dir()?.join(DIRECTORY_PATH);
let mut back_test_uuids = Vec::new();
println!("Directory path: {:?}", path);
// Generate N charts based on config
for i in 0..self.config.num_of_back_tests {
let i = i as usize;
let back_test_uuid = Uuid::new_v4();
let strat_config = self.generate_strategy_config(back_test_uuid)?;
back_test_uuids.push(back_test_uuid);
println!("Making directory for back test: {}", back_test_uuid);
let path = path.join(back_test_uuid.as_simple().to_string());
// Create a directory for the back test helm charts
// Attempt to create the directory
fs::create_dir(path.clone()).await?;
// Create a values.yaml file
let values_file = path.join("values.yaml");
let mut app_config = AppConfig {
fullname_override: format!("bts-{}", back_test_uuid.as_simple()),
name: format!("bts-{}", back_test_uuid.as_simple()),
service_account: ServiceAccountConfig {
create: true,
annotations: Default::default(),
name: format!("bts-{}", back_test_uuid.as_simple()),
},
..Default::default()
};
let strategy_config = self.generate_config(back_test_uuid, &strat_config, &random_market_configs[i]);
let strategy_config = toml::to_string(&strategy_config)?;
app_config.config_toml = strategy_config;
app_config.rust_service = "back-testing-service".to_string();
let app_config_str = serde_yaml::to_string(&app_config)?;
fs::write(values_file, app_config_str).await?;
}
// Create Tiltfile.test
self.generate_tilt_file(back_test_uuids).await?;
Ok(())
}
async fn generate_tilt_file(&self, back_test_uuids: Vec<Uuid>) -> BackTestGeneratorResult<()> {
let path = env::current_dir()?;
let mut tilt_file = TiltFile::default();
for uuid in back_test_uuids {
tilt_file.k8s_yaml.push(K8SYaml {
path: DIRECTORY_PATH.to_string(),
name: format!("bts-{}", uuid.as_simple()),
values: Labels::new(&[&format!("{}/{}/values.yaml", DIRECTORY_PATH, uuid.as_simple())]),
});
tilt_file.k8s_resource.push(K8SResource {
workload: format!("bts-{}", uuid.as_simple()),
resource_deps: Some(Labels::new(&[
"cargo_build_docker",
"update-helm",
"make-secrets",
"postgresql-test",
"tempo",
])),
port_forwards: None,
labels: Some(Labels::new(&["BackTestingService"])),
trigger_mode: Some("TRIGGER_MODE_MANUAL".to_string()),
auto_init: Some(false),
})
}
let path = path.join("Tiltfile.test");
fs::write(path, tilt_file.to_string()).await?;
Ok(())
}
fn generate_ticker_delta_config(&self) -> BackTestGeneratorResult<TickerDeltaConfig> {
let mut rng = rand::thread_rng();
Ok(TickerDeltaConfig {
decay_factor: 0.001,
coefficient: TickerDeltaCoefficientConfig {
time_window: rng.gen_range(
self.config.ticker_delta_coefficient_time_min..=self.config.ticker_delta_coefficient_time_max,
),
increase_by: Decimal::try_from(
rng.gen_range(self.config.ticker_delta_increase.min..=self.config.ticker_delta_increase.max),
)?,
},
ticker_start_time: self.config.ticker_data_config.start_time,
})
}
fn generate_volume_weight_config(&self) -> BackTestGeneratorResult<VolumeWeightConfig> {
let mut rng = rand::thread_rng();
Ok(VolumeWeightConfig {
profit_weight_scalar: Decimal::try_from(
rng.gen_range(self.config.profit_weight.min..=self.config.profit_weight.max),
)?,
balance_weight_scalar: Decimal::try_from(
rng.gen_range(self.config.balance_weight.min..=self.config.balance_weight.max),
)?,
})
}
fn generate_market_configs(&self) -> BackTestGeneratorResult<Vec<MarketConfig>> {
let mut market_configs = Vec::new();
for _ in 0..self.config.num_of_back_tests {
let market_config = MarketConfig {
ticker_delta: self.generate_ticker_delta_config()?,
volume_weights: self.generate_volume_weight_config()?,
};
market_configs.push(market_config);
}
Ok(market_configs)
}
fn generate_strategy_config(&self, back_test_id: Uuid) -> BackTestGeneratorResult<StrategyConfigKind> {
let mut pairs = HashSet::new();
pairs.insert(self.config.pair);
let mut rng = rand::thread_rng();
Ok(StrategyConfigKind::MarketMakerOnTicker(MarketMakerOnTickerConfig {
max_orders: 1,
cancel_threshold: Decimal::try_from(
rng.gen_range(self.config.cancel_threshold.min..=self.config.cancel_threshold.max),
)?,
desired_profit: Decimal::try_from(
rng.gen_range(self.config.desired_profit.min..=self.config.desired_profit.max),
)?,
price_guard: self.config.price_guard.clone(),
set_bid: Decimal::try_from(rng.gen_range(self.config.set_bid.min..=self.config.set_bid.max))?,
// TODO: Switch to work with other types
pair: self.config.pair,
exchange: Exchange::Backtest,
strat_run_id: back_test_id,
}))
}
fn generate_config(
&self,
back_test_uuid: Uuid,
strategy_config: &StrategyConfigKind,
market: &MarketConfig,
) -> BackTestConfig {
let mut market_config = HashMap::new();
let mut market_map = HashMap::new();
market_config.insert(self.config.pair, market.clone());
//market_map.insert(Exchange::Backtest, market_config);
market_config.insert(CurrencyPair::new(Asset::Eth, Asset::Usd), market.clone());
market_map.insert(Exchange::Backtest, market_config);
let mut sec_strategy_config = strategy_config.clone();
match sec_strategy_config {
StrategyConfigKind::TriangularArbitrage(_) => {}
StrategyConfigKind::MarketMakerOnTicker(ref mut config) => {
config.pair = CurrencyPair::new(Asset::Eth, Asset::Usd);
}
}
BackTestConfig {
postgres: self.config.postgres.clone(),
metrics: self.config.metrics.clone(),
balances: self.config.balances.clone(),
strategy_manager: StrategyManagerConfig {
kafka_consumer: None,
kafka_producer: None,
exchange_adapter: None,
strategies: vec![strategy_config.clone(), sec_strategy_config.clone()],
metrics: self.config.metrics.clone(),
server: self.config.server.clone(),
tracing: self.config.tracing.clone(),
notify_subscribers: self.config.notify_subscribers.clone(),
markets: market_map,
postgres: self.config.postgres.clone(),
use_market_balance: true,
back_test: true,
run_id: back_test_uuid,
},
fees: self.config.fees.clone(),
strategy_type: self.config.strategy_type,
run_id: back_test_uuid,
tracing: self.config.tracing.clone(),
ticker_data: self.config.ticker_data_config.clone(),
archive: ArchiveConfig {
start_time: None,
end_time: None,
},
state_strategy: self.config.state_strategy.clone(),
}
}
}
#[tokio::main]
async fn main() -> BackTestGeneratorResult<()> {
let args: Args<BackTestGeneratorConfig> = Args::parse();
let generator = BackTestConfigGenerator::new(args.config);
generator.generate_charts().await?;
Ok(())
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct AppConfig {
replica_count: i32,
name: String,
secrets: Vec<String>,
image: ImageConfig,
image_pull_secrets: Vec<String>,
name_override: String,
fullname_override: String,
service_account: ServiceAccountConfig,
service: ServiceConfig,
ingress: IngressConfig,
autoscaling: AutoscalingConfig,
command: Vec<String>,
#[serde(rename = "SERVICE")]
rust_service: String,
#[serde(rename = "RUST_LOG")]
rust_log: String,
tag: String,
create_secrets: bool,
config_toml: String,
}
impl Default for AppConfig {
fn default() -> Self {
AppConfig {
replica_count: 1,
name: "back-testing-service".to_string(),
secrets: vec!["postgresql_username".to_string(), "postgresql_password".to_string()],
image: ImageConfig {
name: "back-testing-service".to_string(),
repository: "registry.gitlab.com/fdr-group/mono/rs/back-testing-service".to_string(),
pull_policy: "IfNotPresent".to_string(),
tag: "local".to_string(),
},
image_pull_secrets: vec![],
name_override: "".to_string(),
fullname_override: "back-testing-service".to_string(),
service_account: ServiceAccountConfig {
create: true,
annotations: Default::default(),
name: "back-testing-service".to_string(),
},
service: ServiceConfig {
r#type: "ClusterIP".to_string(),
ports: vec![ServicePortConfig {
port: 3000,
target_port: "http".to_string(),
protocol: "TCP".to_string(),
name: "http".to_string(),
}],
},
ingress: IngressConfig { enabled: false },
autoscaling: AutoscalingConfig { enabled: false },
command: vec!["/app/back-testing-service".to_string()],
rust_service: "back-testing-service".to_string(),
rust_log: "Info".to_string(),
tag: "".to_string(),
create_secrets: true,
config_toml: "".to_string(),
}
}
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ImageConfig {
name: String,
repository: String,
pull_policy: String,
tag: String,
}
#[derive(Serialize, Deserialize)]
struct ServiceAccountConfig {
create: bool,
annotations: serde_yaml::Value, // You can use a more specific type if needed
name: String,
}
#[derive(Serialize, Deserialize)]
struct ServiceConfig {
r#type: String,
ports: Vec<ServicePortConfig>,
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
struct ServicePortConfig {
port: i32,
target_port: String,
protocol: String,
name: String,
}
#[derive(Serialize, Deserialize)]
struct IngressConfig {
enabled: bool,
}
#[derive(Serialize, Deserialize)]
struct AutoscalingConfig {
enabled: bool,
}
| 0 |
tilt | /mono/crates/back_testing_config_generator/src/tilt/mod.rs | use std::{
fmt,
fmt::{Display, Formatter},
};
pub struct TiltFile {
pub local_resources: Vec<LocalResource>,
pub update_settings: UpdateSettings,
pub load_settings: Vec<LoadSetting>,
pub min_tilt_version: MinTiltVersion,
pub min_k8s_version: MinK8sVersion,
pub k8s_yaml: Vec<K8SYaml>,
pub k8s_resource: Vec<K8SResource>,
}
impl Display for TiltFile {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
writeln!(f, "{}", self.update_settings)?;
for item in self.load_settings.iter() {
writeln!(f, "{}", item)?;
}
writeln!(f, "{}", self.min_tilt_version)?;
writeln!(f, "{}", self.min_k8s_version)?;
for item in self.local_resources.iter() {
writeln!(f, "{}", item)?;
}
for item in self.k8s_yaml.iter() {
writeln!(f, "{}", item)?;
}
for item in self.k8s_resource.iter() {
writeln!(f, "{}", item)?;
}
Ok(())
}
}
impl Default for TiltFile {
fn default() -> Self {
TiltFile {
local_resources: vec![
LocalResource {
name: "make-secrets".to_string(),
command: "make secrets".to_string(),
labels: Some(Labels::new(&["Build"])),
allow_parallel: Some(true),
resource_deps: None,
},
LocalResource {
name: "cargo_build_docker".to_string(),
command: "./scripts/docker-build-for-k8s.sh -o".to_string(),
labels: Some(Labels::new(&["Build"])),
allow_parallel: Some(true),
resource_deps: None,
},
LocalResource {
name: "update-helm".to_string(),
command: "./scripts/helm-update.sh".to_string(),
labels: Some(Labels::new(&["Build"])),
allow_parallel: Some(true),
resource_deps: None,
},
],
update_settings: UpdateSettings {
max_parallel_updates: 8,
},
load_settings: vec![
LoadSetting {
name: "ext://min_tilt_version".to_string(),
command: "min_tilt_version".to_string(),
},
LoadSetting {
name: "ext://min_k8s_version".to_string(),
command: "min_k8s_version".to_string(),
},
],
min_tilt_version: MinTiltVersion("0.33.5".to_string()),
min_k8s_version: MinK8sVersion("1.27.0".to_string()),
k8s_yaml: vec![
K8SYaml {
path: "./helm/prometheus".to_string(),
name: "prometheus".to_string(),
values: Labels::new(&["helm/prometheus/values.yaml", "helm/prometheus/values-local.yaml"]),
},
K8SYaml {
path: "./helm/grafana".to_string(),
name: "grafana".to_string(),
values: Labels::new(&[
"helm/grafana/values.yaml",
"helm/grafana/values-common.yaml",
"helm/grafana/values-local.yaml",
]),
},
K8SYaml {
path: "./helm/grafana-tempo".to_string(),
name: "tempo".to_string(),
values: Labels::new(&["helm/grafana-tempo/values.yaml", "helm/grafana-tempo/values-local.yaml"]),
},
K8SYaml {
path: "./helm/postgresql-test".to_string(),
name: "postgresql-test".to_string(),
values: Labels::new(&[
"helm/postgresql-test/values.yaml",
"helm/postgresql-test/values-common.yaml",
"helm/postgresql-test/values-local.yaml",
]),
},
],
k8s_resource: vec![
K8SResource {
workload: "grafana".to_string(),
resource_deps: Some(Labels::new(&["update-helm"])),
port_forwards: Some(PortForwards {
forwards: vec![PortForward {
port: "3000".to_string(),
forward_to: "3000".to_string(),
name: "Grafana".to_string(),
}],
}),
labels: Some(Labels::new(&["Observability"])),
trigger_mode: None,
auto_init: None,
},
K8SResource {
workload: "prometheus-server".to_string(),
resource_deps: Some(Labels::new(&["update-helm"])),
port_forwards: Some(PortForwards {
forwards: vec![PortForward {
port: "9090".to_string(),
forward_to: "9090".to_string(),
name: "Prometheus".to_string(),
}],
}),
labels: Some(Labels::new(&["Observability"])),
trigger_mode: None,
auto_init: None,
},
K8SResource {
workload: "prometheus-alertmanager".to_string(),
resource_deps: Some(Labels::new(&["update-helm"])),
port_forwards: Some(PortForwards {
forwards: vec![PortForward {
port: "9093".to_string(),
forward_to: "9093".to_string(),
name: "Prometheus".to_string(),
}],
}),
labels: Some(Labels::new(&["Observability"])),
trigger_mode: None,
auto_init: None,
},
K8SResource {
workload: "tempo".to_string(),
resource_deps: Some(Labels::new(&["update-helm"])),
port_forwards: Some(PortForwards {
forwards: vec![
PortForward {
port: "3100".to_string(),
forward_to: "3100".to_string(),
name: "Tempo".to_string(),
},
PortForward {
port: "4317".to_string(),
forward_to: "4317".to_string(),
name: "OTLP GRPC".to_string(),
},
PortForward {
port: "4318".to_string(),
forward_to: "4318".to_string(),
name: "OTLP HTTP".to_string(),
},
],
}),
labels: Some(Labels::new(&["Observability"])),
trigger_mode: None,
auto_init: None,
},
K8SResource {
workload: "postgresql-test".to_string(),
resource_deps: Some(Labels::new(&["update-helm"])),
port_forwards: Some(PortForwards {
forwards: vec![PortForward {
port: "5432".to_string(),
forward_to: "5432".to_string(),
name: "PostgreSQL".to_string(),
}],
}),
labels: Some(Labels::new(&["Database"])),
trigger_mode: Some("TRIGGER_MODE_MANUAL".to_string()),
auto_init: None,
},
],
}
}
}
pub struct MinTiltVersion(String);
pub struct MinK8sVersion(String);
impl Display for MinTiltVersion {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "min_tilt_version('{}')", self.0)
}
}
impl Display for MinK8sVersion {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "min_k8s_version('{}')", self.0)
}
}
pub struct LoadSetting {
pub name: String,
pub command: String,
}
impl Display for LoadSetting {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "load('{}', '{}')", self.name, self.command)
}
}
pub struct UpdateSettings {
pub max_parallel_updates: u32,
}
impl Display for UpdateSettings {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "update_settings(max_parallel_updates={})", self.max_parallel_updates)
}
}
pub struct LocalResource {
pub name: String,
pub command: String,
pub labels: Option<Labels>,
pub allow_parallel: Option<bool>,
pub resource_deps: Option<Labels>,
}
#[derive(Debug)]
pub struct Labels(Vec<String>);
impl Labels {
pub fn new(labels: &[&str]) -> Labels {
Labels(labels.iter().map(|s| s.to_string()).collect())
}
}
impl Display for Labels {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "[")?;
for (index, item) in self.0.iter().enumerate() {
if index > 0 {
write!(f, ", ")?;
}
write!(f, "'{}'", item)?;
}
write!(f, "]")
}
}
impl Display for LocalResource {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
writeln!(f, "local_resource(\n\t'{}',\n\t'{}',", self.name, self.command)?;
if let Some(allow_parallel) = &self.allow_parallel {
let allow_parallel = if *allow_parallel { "True" } else { "False" };
writeln!(f, "\tallow_parallel={},", allow_parallel)?;
}
if let Some(resource_deps) = &self.resource_deps {
writeln!(f, "\tresource_deps={},", resource_deps)?;
}
if let Some(labels) = &self.labels {
writeln!(f, "\tlabels={}", labels)?;
}
writeln!(f, ")")
}
}
pub struct K8SYaml {
pub path: String,
pub name: String,
pub values: Labels,
}
impl Display for K8SYaml {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
writeln!(
f,
"k8s_yaml(helm(\n\t'{}',\n\tname='{}',\n\tvalues={}\n))",
self.path, self.name, self.values
)
}
}
pub struct PortForwards {
pub forwards: Vec<PortForward>,
}
impl Display for PortForwards {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(f, "port_forwards=[")?;
for (index, item) in self.forwards.iter().enumerate() {
if index > 0 {
write!(f, ", ")?;
}
write!(f, "{}", item)?;
}
write!(f, "]")
}
}
pub struct PortForward {
pub port: String,
pub forward_to: String,
pub name: String,
}
impl Display for PortForward {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
write!(
f,
"port_forward({}, {}, name='{}')",
self.port, self.forward_to, self.name
)
}
}
pub struct K8SResource {
pub workload: String,
pub resource_deps: Option<Labels>,
pub port_forwards: Option<PortForwards>,
pub labels: Option<Labels>,
pub trigger_mode: Option<String>,
pub auto_init: Option<bool>,
}
impl Display for K8SResource {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
writeln!(f, "k8s_resource(")?;
if let Some(resource_deps) = &self.resource_deps {
writeln!(f, "\tresource_deps={},", resource_deps)?;
}
if let Some(port_forwards) = &self.port_forwards {
writeln!(f, "\t{},", port_forwards)?;
}
if let Some(labels) = &self.labels {
writeln!(f, "\tlabels={},", labels)?;
}
if let Some(trigger_mode) = &self.trigger_mode {
writeln!(f, "\ttrigger_mode={},", trigger_mode)?;
}
if let Some(auto_init) = &self.auto_init {
let auto_init = if *auto_init { "True" } else { "False" };
writeln!(f, "\tauto_init={},", auto_init)?;
}
writeln!(f, "\tworkload='{}'", self.workload)?;
writeln!(f, ")")
}
}
| 0 |
config | /mono/crates/back_testing_config_generator/src/config/config.toml | num_of_back_tests = 1
pair = "dot_usd"
strategy_type = "MARKET_MAKER_ON_TICKER"
state_strategy = "InMemory"
ticker_start_time = "2023-11-24 20:37:20.070483 +00:00"
ticker_delta_coefficient_time_min = 10
ticker_delta_coefficient_time_max = 100
price_guard = "SimplifiedAverageCost"
[cancel_threshold]
min = 0.0003
max = 0.0008
[set_bid]
min = 1
max = 100
[desired_profit]
min = 0.0003
max = 0.0012
[profit_weight]
min = 0
max = 6
[balance_weight]
min = 0
max = 6
[ticker_delta_increase]
min = 0.01
max = 0.5
use_market_balance = true
[event_receiver.Kafka]
group_id = "backtest"
bootstrap_servers = "redpanda:9093"
enable_partition_eof = "false"
session_timeout_ms = "60000"
auto_commit = "false"
offset_reset = "latest"
topics = []
[postgres]
hostname = "postgresql-test"
port = 5432
database = "trading-test"
max_connections = 10
username = "trading-test"
password = "trading-test"
sample_ratio = 0.000000001
[[balances]]
asset = "DOT"
amount = { available = 0, total = 0 }
[[balances]]
asset = "USD"
amount = { available = 10000, total = 10000 }
[metrics]
prefix = "fdr"
[tracing]
level = "DEBUG"
tempo_url = "http://localhost"
tempo_port = 4317
service_name = "back_testing_service"
[[fees]]
pair = "dot_usd"
fee = 0.0000
[server]
listen_address = "0.0.0.0"
port = 3000
[[request_sender.Channel]]
url = "http://back-testing-service"
port = 3000
exchange = "BACKTEST"
strategy = "MARKET_MAKER_ON_TICKER"
[event_sender.Channel]
url = "http://back-testing-service"
port = 3000
exchange = "BACKTEST"
strategy = "MARKET_MAKER_ON_TICKER"
[order_book_manager]
pairs = ["dot_usd"]
[notify_subscribers]
ticker = true
book = false
order_cancelled = true
trade = true
alert = true
order_placed = true
order_error = true
| 0 |
config | /mono/crates/back_testing_config_generator/src/config/mod.rs | use chrono::{DateTime, Utc};
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
use fdr_common::{
config::MetricsConfig,
crypto::{
asset_balance::AssetBalance,
assets::{Asset, CurrencyPair},
},
exchange::Exchange,
tracing::config::TracingConfig,
TradingStrategy,
};
use fdr_store::config::PostgresConfig;
use strategy_manager::config::StrategyManagerConfig;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum StateStrategy {
InMemory,
Database,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BalanceConfig {
pub asset: Asset,
pub amount: AssetBalance,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Fees {
pub pair: CurrencyPair,
pub fee: Decimal,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TickerDataConfig {
pub generate: bool,
pub generator_seed: u64,
pub interval: i64,
#[serde(deserialize_with = "deserialize_datetime_from_timestamp")]
pub start_time: Option<DateTime<Utc>>,
#[serde(deserialize_with = "deserialize_datetime_from_timestamp")]
pub end_time: Option<DateTime<Utc>>,
pub exchange: Exchange,
pub pairs: Vec<CurrencyPair>,
}
fn deserialize_datetime_from_timestamp<'de, D>(deserializer: D) -> Result<Option<DateTime<Utc>>, D::Error>
where
D: serde::Deserializer<'de>,
{
let timestamp = DateTime::from_timestamp(i64::deserialize(deserializer)?, 0)
.expect("Timestamps from exchange should not overflow");
Ok(Some(timestamp))
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BackTestConfig {
pub postgres: PostgresConfig,
pub metrics: MetricsConfig,
pub balances: Vec<BalanceConfig>,
pub strategy_manager: StrategyManagerConfig,
pub fees: Vec<Fees>,
pub strategy_type: TradingStrategy,
pub run_id: Uuid,
pub tracing: TracingConfig,
pub ticker_data: TickerDataConfig,
pub archive: ArchiveConfig,
pub state_strategy: StateStrategy,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ArchiveConfig {
pub start_time: Option<DateTime<Utc>>,
pub end_time: Option<DateTime<Utc>>,
}
| 0 |
.idea | /mono/.idea/vcs.xml | <?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
</component>
</project> | 0 |
.idea | /mono/.idea/workspace.xml | <?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="AutoImportSettings">
<option name="autoReloadType" value="ALL" />
</component>
<component name="CargoProjects">
<cargoProject FILE="$PROJECT_DIR$/Cargo.toml" />
</component>
<component name="ChangeListManager">
<list default="true" id="a74b574f-41e9-4215-85d5-123291feca38" name="Changes" comment="">
<change afterPath="$PROJECT_DIR$/crates/technical_analysis/src/indicators/vwap.rs" afterDir="false" />
<change beforePath="$PROJECT_DIR$/crates/technical_analysis/src/indicators/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/crates/technical_analysis/src/indicators/mod.rs" afterDir="false" />
<change beforePath="$PROJECT_DIR$/crates/technical_analysis/src/value.rs" beforeDir="false" afterPath="$PROJECT_DIR$/crates/technical_analysis/src/value.rs" afterDir="false" />
</list>
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
<option name="LAST_RESOLUTION" value="IGNORE" />
</component>
<component name="FileTemplateManagerImpl">
<option name="RECENT_TEMPLATES">
<list>
<option value="Rust File" />
</list>
</option>
</component>
<component name="Git.Settings">
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
</component>
<component name="KubernetesApiPersistence">{}</component>
<component name="KubernetesApiProvider">{
"isMigrated": true
}</component>
<component name="MacroExpansionManager">
<option name="directoryName" value="jisb7ni9" />
</component>
<component name="ProjectColorInfo">{
"associatedIndex": 8
}</component>
<component name="ProjectId" id="2hG94rdMxa2y849rzVoC99jwnpu" />
<component name="ProjectViewState">
<option name="hideEmptyMiddlePackages" value="true" />
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent">{
"keyToString": {
"RunOnceActivity.ShowReadmeOnStart": "true",
"RunOnceActivity.rust.reset.selective.auto.import": "true",
"git-widget-placeholder": "main",
"node.js.detected.package.eslint": "true",
"node.js.selected.package.eslint": "(autodetect)",
"nodejs_package_manager_path": "npm",
"org.rust.cargo.project.model.PROJECT_DISCOVERY": "true",
"org.rust.cargo.project.model.impl.CargoExternalSystemProjectAware.subscribe.first.balloon": "",
"org.rust.first.attach.projects": "true",
"settings.editor.selected.configurable": "editor.preferences.fonts.default"
}
}</component>
<component name="RunManager" selected="Cargo.Test mono">
<configuration name="Run archive-service" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package archive-service --bin archive-service" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
<configuration name="Run back-testing-service" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package back-testing-service --bin back-testing-service" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
<configuration name="Run generator" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package config-generator --bin generator" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
<configuration name="Run indicator-service" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package indicator-service --bin indicator-service" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
<configuration name="Run proxy-kraken" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package exchange-proxy --bin proxy-kraken" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
<configuration name="Run strategy-manager" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="run --package strategy-manager --bin strategy-manager" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
<configuration name="Test mono" type="CargoCommandRunConfiguration" factoryName="Cargo Command">
<option name="command" value="test --workspace" />
<option name="workingDirectory" value="file://$PROJECT_DIR$" />
<envs />
<option name="emulateTerminal" value="true" />
<option name="channel" value="DEFAULT" />
<option name="requiredFeatures" value="true" />
<option name="allFeatures" value="false" />
<option name="withSudo" value="false" />
<option name="buildTarget" value="REMOTE" />
<option name="backtrace" value="SHORT" />
<option name="isRedirectInput" value="false" />
<option name="redirectInputPath" value="" />
<method v="2">
<option name="CARGO.BUILD_TASK_PROVIDER" enabled="true" />
</method>
</configuration>
</component>
<component name="RustProjectSettings">
<option name="toolchainHomeDirectory" value="$USER_HOME$/.cargo/bin" />
</component>
<component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
<component name="TaskManager">
<task active="true" id="Default" summary="Default task">
<changelist id="a74b574f-41e9-4215-85d5-123291feca38" name="Changes" comment="" />
<created>1717209359107</created>
<option name="number" value="Default" />
<option name="presentableId" value="Default" />
<updated>1717209359107</updated>
<workItem from="1717209360010" duration="83000" />
<workItem from="1717209447898" duration="1447000" />
<workItem from="1717210902375" duration="1676000" />
<workItem from="1717422658927" duration="1915000" />
<workItem from="1717424579596" duration="5599000" />
<workItem from="1717436344810" duration="6779000" />
<workItem from="1717503778666" duration="1205000" />
<workItem from="1717592898041" duration="5083000" />
<workItem from="1717727937628" duration="341000" />
<workItem from="1717815762042" duration="4648000" />
<workItem from="1718213942475" duration="2390000" />
<workItem from="1718299526037" duration="602000" />
<workItem from="1718385695049" duration="895000" />
</task>
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="3" />
</component>
<component name="XSLT-Support.FileAssociations.UIState">
<expand />
<select />
</component>
</project> | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.