use std::sync::Arc;
use async_trait::async_trait;
use color_eyre::Result;
use rust_decimal::Decimal;
use serde::Deserialize;
use crate::{
ports::{MarketDataSource, TradingGateway},
strategies::{CommonParams, Strategy, params_from_table},
};
#[derive(Debug, Clone, Deserialize)]
pub struct MarketCapConfig {
#[serde(flatten)]
pub common: CommonParams,
#[serde(default = "default_quote")]
pub quote_asset: String,
pub weights: std::collections::BTreeMap<String, Decimal>,
}
fn default_quote() -> String {
String::from("USDT")
}
impl MarketCapConfig {
pub fn from_params(table: &toml::Table) -> Result<Self> {
params_from_table(table)
}
}
pub struct MarketCap {
inner: crate::strategies::rebalance::Rebalance,
}
impl MarketCap {
pub fn new(
config: MarketCapConfig,
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
) -> Self {
let rc = crate::strategies::rebalance::RebalanceConfig {
common: config.common,
quote_asset: config.quote_asset,
targets: config.weights,
band_pct: Decimal::new(5, 2),
};
Self { inner: crate::strategies::rebalance::Rebalance::new(rc, gateway, market) }
}
pub async fn tick(&self) -> Result<std::collections::BTreeMap<String, Decimal>> {
self.inner.tick().await
}
}
#[async_trait]
impl Strategy for MarketCap {
async fn run(&self) -> Result<()> {
self.inner.run().await
}
}
#[cfg(test)]
mod tests {
use std::{collections::BTreeMap, time::Duration};
use async_trait::async_trait;
use proptest::prelude::*;
use rust_decimal_macros::dec;
use super::*;
use crate::{
adapters::MockAdapter,
ports::{MarketDataSource, MarketEventStream, OverflowPolicy, PortError, TradingGateway},
proto::{market, trading},
strategies::Strategy,
};
fn cap(config: MarketCapConfig, market: Arc<dyn MarketDataSource>) -> MarketCap {
let gateway: Arc<dyn TradingGateway> = Arc::new(MockAdapter::new(dec!(100)));
MarketCap::new(config, gateway, market)
}
fn config_of(table: &str) -> MarketCapConfig {
let parsed: toml::Table = toml::from_str(table).expect("valid toml");
MarketCapConfig::from_params(&parsed).expect("parse")
}
#[test]
fn config_parses_from_params_table() {
let cfg = config_of("symbol = \"BTC/USDT\"\nweights = { BTC = \"0.6\", ETH = \"0.4\" }");
assert_eq!(cfg.common.symbol, "BTC/USDT");
assert_eq!(cfg.quote_asset, "USDT", "USDT is the documented default valuation currency");
assert_eq!(cfg.weights["BTC"], dec!(0.6));
assert_eq!(cfg.weights["ETH"], dec!(0.4));
}
#[test]
fn the_quote_asset_is_overridable() {
let cfg =
config_of("symbol = \"BTC/USDT\"\nquote_asset = \"BTC\"\nweights = { ETH = \"1\" }");
assert_eq!(cfg.quote_asset, "BTC");
}
#[test]
fn missing_weights_fails_config() {
let parsed: toml::Table = toml::from_str("symbol = \"BTC/USDT\"").expect("valid toml");
let err = MarketCapConfig::from_params(&parsed).expect_err("weights is required");
assert!(err.to_string().contains("weights"), "{err}");
}
#[test]
fn missing_symbol_fails_config() {
let parsed: toml::Table = toml::from_str("weights = { BTC = \"1\" }").expect("valid toml");
let err = MarketCapConfig::from_params(&parsed).expect_err("symbol is required");
assert!(err.to_string().contains("symbol"), "{err}");
}
#[test]
fn an_empty_weight_table_is_accepted_and_builds() {
let cfg = config_of("symbol = \"BTC/USDT\"\nweights = {}");
assert!(cfg.weights.is_empty());
let market: Arc<dyn MarketDataSource> = Arc::new(MockAdapter::new(dec!(100)));
let _preset = cap(cfg, market);
}
#[test]
fn a_weight_table_that_does_not_sum_to_one_is_accepted() {
let cfg = config_of("symbol = \"BTC/USDT\"\nweights = { BTC = \"0.6\", ETH = \"0.6\" }");
let total: Decimal = cfg.weights.values().copied().sum();
assert_eq!(total, dec!(1.2));
}
#[test]
fn weights_keep_their_configured_precision() {
let cfg =
config_of("symbol = \"BTC/USDT\"\nweights = { BTC = \"0.33333333333333333333\" }");
assert_eq!(cfg.weights["BTC"].to_string(), "0.33333333333333333333");
}
#[tokio::test]
async fn a_tick_delegates_and_returns_the_planned_deltas() {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
let gateway: Arc<dyn TradingGateway> = adapter.clone();
let market: Arc<dyn MarketDataSource> = adapter.clone();
let preset = MarketCap::new(
config_of("symbol = \"USD/USDT\"\nweights = { USD = \"0.5\" }"),
gateway,
market,
);
let plan = preset.tick().await.expect("tick");
assert_eq!(plan["USD"], dec!(-500_000), "half the portfolio is planned away");
let open = adapter
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("test setup");
assert_eq!(open.len(), 1, "the delegated tick traded once");
assert_eq!(open[0].symbol, "USDUSDT");
}
#[tokio::test]
async fn the_preset_trades_on_a_five_percent_band() {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
let gateway: Arc<dyn TradingGateway> = adapter.clone();
let market: Arc<dyn MarketDataSource> = adapter.clone();
let preset = MarketCap::new(
config_of("symbol = \"USD/USDT\"\nweights = { USD = \"0.95\" }"),
gateway.clone(),
market.clone(),
);
preset.tick().await.expect("tick");
let resting = adapter
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("test setup");
assert!(resting.is_empty(), "a drift of exactly 5% is inside the band");
let past = MarketCap::new(
config_of("symbol = \"USD/USDT\"\nweights = { USD = \"0.94\" }"),
gateway,
market,
);
past.tick().await.expect("tick");
let resting = adapter
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("test setup");
assert_eq!(resting.len(), 1, "6% of drift is outside a 5% band");
}
#[tokio::test]
async fn the_delegated_rebalance_trades_against_the_weight_table() {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
let gateway: Arc<dyn TradingGateway> = adapter.clone();
let market: Arc<dyn MarketDataSource> = adapter.clone();
let preset = MarketCap::new(
config_of("symbol = \"USD/USDT\"\nweights = { USD = \"0.5\" }"),
gateway,
market,
);
let runner = tokio::spawn(async move { preset.run().await });
tokio::time::sleep(Duration::from_millis(50)).await;
runner.abort();
let open = adapter
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("test setup");
assert_eq!(open.len(), 1, "the delegated tick must have traded once");
assert_eq!(open[0].symbol, "USDUSDT");
}
#[tokio::test]
async fn a_port_failure_does_not_end_the_delegated_run_loop() {
let cfg = config_of("symbol = \"USD/USDT\"\nweights = { USD = \"0.5\" }");
let preset = cap(cfg, Arc::new(FailingPrices));
let outcome = tokio::time::timeout(Duration::from_millis(50), preset.run()).await;
assert!(outcome.is_err(), "the run loop must keep polling after a price failure");
}
struct FailingPrices;
#[async_trait]
impl MarketDataSource for FailingPrices {
async fn fetch_ticker(
&self,
_req: market::FetchTickerRequest,
) -> Result<market::Ticker, PortError> {
Err(PortError::Transport("ticker feed down".into()))
}
async fn fetch_order_book(
&self,
_req: market::FetchOrderBookRequest,
) -> Result<market::OrderBook, PortError> {
Err(PortError::Transport("book feed down".into()))
}
async fn get_candles(
&self,
_req: market::GetCandlesRequest,
) -> Result<market::GetCandlesResponse, PortError> {
Err(PortError::Transport("candle feed down".into()))
}
async fn list_symbols(
&self,
_req: market::ListSymbolsRequest,
) -> Result<market::ListSymbolsResponse, PortError> {
Err(PortError::Transport("symbol feed down".into()))
}
async fn search_symbols(
&self,
_req: market::SearchSymbolsRequest,
) -> Result<market::SearchSymbolsResponse, PortError> {
Err(PortError::Transport("symbol feed down".into()))
}
async fn list_tickers(
&self,
_req: market::ListTickersRequest,
) -> Result<market::ListTickersResponse, PortError> {
Err(PortError::Transport("ticker feed down".into()))
}
async fn subscribe_market_data(
&self,
_req: market::StreamMarketDataRequest,
_policy: OverflowPolicy,
) -> Result<MarketEventStream, PortError> {
Err(PortError::Unsupported("no stream".into()))
}
}
proptest! {
#![proptest_config(ProptestConfig::with_cases(128))]
#[test]
fn the_weight_table_round_trips_unchanged(
entries in prop::collection::vec(("[A-Z]{2,5}", 0i64..10_000), 0..8),
) {
let mut expected: BTreeMap<String, i64> = BTreeMap::new();
for (asset, weight) in entries {
let _ = expected.insert(asset, weight);
}
let body: Vec<String> = expected
.iter()
.map(|(asset, weight)| {
format!("{asset} = \"{}.{:02}\"", weight / 100, weight % 100)
})
.collect();
let doc = format!("symbol = \"BTC/USDT\"\nweights = {{ {} }}", body.join(", "));
let cfg = MarketCapConfig::from_params(
&toml::from_str::<toml::Table>(&doc).expect("the generated table parses"),
)
.expect("the generated weights parse");
prop_assert_eq!(cfg.weights.len(), expected.len());
for (asset, weight) in &expected {
prop_assert_eq!(cfg.weights[asset.as_str()], Decimal::from(*weight) / dec!(100));
}
}
}
}