use std::sync::{Arc, OnceLock};
use color_eyre::Result;
use super::{
Strategy, adx_trend, amm_arb, apt_mm, autoborrow, avellaneda_mm_v2, balance_align, basis_mm,
bb_keltner_squeeze, boll_grid, bollinger_v2, convert, cross_depth_maker, cross_exchange_mm,
cross_fixed_maker, cross_maker, cvd_divergence, darvas_box, dca_executor, dca_scheduler,
deposit_transfer, dman_v3, dual_thrust, ema_cross, fixed_maker, glft_mm, grid_strike, hedge,
hedge_grid, ichimoku, irr, liquidity_mining, macd_bb, market_cap, mean_reversion,
momentum_factor, nav_recorder, obi_mm, params::params_from_table, perpetual_mm, pmm_dynamic,
premium_monitor, pure_market_making, queue_mm, random_entry, rebalance, sentinel, simple_grid,
simplified_glft_mm, skewed_grid, spot_perp_arb, stat_arb, supertrend, twap_executor,
vwap_executor, xfunding_lite,
};
use crate::{
config::Config,
ports::{
FundingRateSource, MarketDataSource, TradingGateway, TriggerOrderGateway, VenueOpInvoker,
WalletGateway,
},
};
pub struct StrategyContext {
pub config: Config,
pub gateway: Arc<dyn TradingGateway>,
pub market: Arc<dyn MarketDataSource>,
pub funding: Arc<dyn FundingRateSource>,
pub triggers: Arc<dyn TriggerOrderGateway>,
pub ops: Arc<dyn VenueOpInvoker>,
pub wallet: Arc<dyn WalletGateway>,
}
pub type StrategyFactory = fn(&StrategyContext) -> Result<Box<dyn Strategy>>;
pub struct StrategyDescriptor {
pub name: &'static str,
pub factory: StrategyFactory,
}
static REGISTRY: OnceLock<Vec<StrategyDescriptor>> = OnceLock::new();
fn build_dca_scheduler(ctx: &StrategyContext) -> Result<Box<dyn Strategy>> {
let cfg = dca_scheduler::DcaSchedulerConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(dca_scheduler::DcaScheduler::new(cfg, ctx.gateway.clone())))
}
pub fn registry() -> &'static [StrategyDescriptor] {
REGISTRY.get_or_init(|| {
vec![
StrategyDescriptor {
name: "simple_grid",
factory: |ctx| {
let cfg = simple_grid::SimpleGridConfig::from_config(&ctx.config)?;
Ok(Box::new(simple_grid::SimpleGrid::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "adx_trend",
factory: |ctx| {
let cfg =
adx_trend::AdxTrendConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(adx_trend::AdxTrend::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "bb_keltner_squeeze",
factory: |ctx| {
let cfg = bb_keltner_squeeze::BbKeltnerSqueezeConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(bb_keltner_squeeze::BbKeltnerSqueeze::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "cvd_divergence",
factory: |ctx| {
let cfg = cvd_divergence::CvdDivergenceConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(cvd_divergence::CvdDivergence::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "darvas_box",
factory: |ctx| {
let cfg = darvas_box::DarvasBoxConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(darvas_box::DarvasBox::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "dual_thrust",
factory: |ctx| {
let cfg = dual_thrust::DualThrustConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(dual_thrust::DualThrust::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "ichimoku",
factory: |ctx| {
let cfg =
ichimoku::IchimokuConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(ichimoku::Ichimoku::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "mean_reversion",
factory: |ctx| {
let cfg = mean_reversion::MeanReversionConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(mean_reversion::MeanReversion::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "momentum_factor",
factory: |ctx| {
let cfg = momentum_factor::MomentumFactorConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(momentum_factor::MomentumFactor::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "ema_cross",
factory: |ctx| {
let cfg =
ema_cross::EmaCrossConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(ema_cross::EmaCross::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "supertrend",
factory: |ctx| {
let cfg = supertrend::SupertrendConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(supertrend::Supertrend::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "boll_grid",
factory: |ctx| {
let cfg =
boll_grid::BollGridConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(boll_grid::BollGrid::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor { name: "dca_scheduler", factory: build_dca_scheduler },
StrategyDescriptor { name: "dca", factory: build_dca_scheduler },
StrategyDescriptor {
name: "fixed_maker",
factory: |ctx| {
let cfg = fixed_maker::FixedMakerConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(fixed_maker::FixedMaker::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "random_entry",
factory: |ctx| {
let cfg = random_entry::RandomEntryConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(random_entry::RandomEntry::new(cfg, ctx.gateway.clone())))
},
},
StrategyDescriptor {
name: "xfunding_lite",
factory: |ctx| {
let cfg = xfunding_lite::XfundingLiteConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(xfunding_lite::XfundingLite::new(
cfg,
ctx.gateway.clone(),
ctx.funding.clone(),
)))
},
},
StrategyDescriptor {
name: "sentinel",
factory: |ctx| {
let cfg =
sentinel::SentinelConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(sentinel::Sentinel::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "autoborrow",
factory: |ctx| {
let cfg = autoborrow::AutoborrowConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(autoborrow::Autoborrow::new(cfg, ctx.ops.clone())))
},
},
StrategyDescriptor {
name: "convert",
factory: |ctx| {
let cfg =
convert::ConvertConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(convert::Convert::new(cfg, ctx.ops.clone())))
},
},
StrategyDescriptor {
name: "deposit_transfer",
factory: |ctx| {
let cfg = deposit_transfer::DepositTransferConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(deposit_transfer::DepositTransfer::new(cfg, ctx.wallet.clone())))
},
},
StrategyDescriptor {
name: "cross_fixed_maker",
factory: |ctx| {
let cfg = params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(cross_fixed_maker::CrossFixedMaker::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "cross_depth_maker",
factory: |ctx| {
let cfg = params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(cross_depth_maker::CrossDepthMaker::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "cross_maker",
factory: |ctx| {
let cfg = params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(cross_maker::CrossMaker::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "hedge_grid",
factory: |ctx| {
let cfg = params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(hedge_grid::HedgeGrid::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "balance_align",
factory: |ctx| {
let cfg = params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(balance_align::BalanceAlign::new(
cfg,
ctx.gateway.clone(),
ctx.wallet.clone(),
)))
},
},
StrategyDescriptor {
name: "premium_monitor",
factory: |ctx| {
let cfg: premium_monitor::PremiumMonitorConfig =
params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(premium_monitor::PremiumMonitor::new(cfg, ctx.market.clone())))
},
},
StrategyDescriptor {
name: "nav_recorder",
factory: |ctx| {
let cfg = nav_recorder::NavRecorderConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(nav_recorder::NavRecorder::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "rebalance",
factory: |ctx| {
let cfg = rebalance::RebalanceConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(rebalance::Rebalance::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "market_cap",
factory: |ctx| {
let cfg = market_cap::MarketCapConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(market_cap::MarketCap::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "irr",
factory: |ctx| {
let cfg = irr::IrrConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(irr::Irr::new(cfg, ctx.gateway.clone())))
},
},
StrategyDescriptor {
name: "skewed_grid",
factory: |ctx| {
let cfg = skewed_grid::SkewedGridConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(skewed_grid::SkewedGrid::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "obi_mm",
factory: |ctx| {
let cfg = obi_mm::ObiMmConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(obi_mm::ObiMm::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "basis_mm",
factory: |ctx| {
let cfg =
basis_mm::BasisMmConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(basis_mm::BasisMm::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "apt_mm",
factory: |ctx| {
let cfg = apt_mm::AptMmConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(apt_mm::AptMm::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "queue_mm",
factory: |ctx| {
let cfg =
queue_mm::QueueMmConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(queue_mm::QueueMm::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "glft_mm",
factory: |ctx| {
let cfg =
glft_mm::GlftMmConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(glft_mm::GlftMm::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "simplified_glft_mm",
factory: |ctx| {
let cfg = simplified_glft_mm::SimplifiedGlftMmConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(simplified_glft_mm::SimplifiedGlftMm::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "pure_market_making",
factory: |ctx| {
let cfg = pure_market_making::PmmConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(pure_market_making::Pmm::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "avellaneda_mm_v2",
factory: |ctx| {
let cfg = avellaneda_mm_v2::AvellanedaMmV2Config::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(avellaneda_mm_v2::AvellanedaMmV2::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "perpetual_mm",
factory: |ctx| {
let cfg = perpetual_mm::PerpMmConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(perpetual_mm::PerpMm::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
ctx.funding.clone(),
)))
},
},
StrategyDescriptor {
name: "cross_exchange_mm",
factory: |ctx| {
let cfg = params_from_table(ctx.config.strategy.params.table())?;
Ok(Box::new(cross_exchange_mm::Xemm::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "amm_arb",
factory: |ctx| {
let cfg =
amm_arb::AmmArbConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(amm_arb::AmmArb::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "spot_perp_arb",
factory: |ctx| {
let cfg = spot_perp_arb::SpotPerpArbConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(spot_perp_arb::SpotPerpArb::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "hedge",
factory: |ctx| {
let cfg = hedge::HedgeConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(hedge::Hedge::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "liquidity_mining",
factory: |ctx| {
let cfg = liquidity_mining::LiqMiningConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(liquidity_mining::LiqMining::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "bollinger_v2",
factory: |ctx| {
let cfg = bollinger_v2::BollingerV2Config::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(bollinger_v2::BollingerV2::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "dman_v3",
factory: |ctx| {
let cfg =
dman_v3::DmanV3Config::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(dman_v3::DmanV3::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "macd_bb",
factory: |ctx| {
let cfg =
macd_bb::MacdBbConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(macd_bb::MacdBb::new(cfg, ctx.gateway.clone(), ctx.market.clone())))
},
},
StrategyDescriptor {
name: "grid_strike",
factory: |ctx| {
let cfg = grid_strike::GridStrikeConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(grid_strike::GridStrike::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "stat_arb",
factory: |ctx| {
let cfg =
stat_arb::StatArbConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(stat_arb::StatArb::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "pmm_dynamic",
factory: |ctx| {
let cfg = pmm_dynamic::PmmDynamicConfig::from_params(
ctx.config.strategy.params.table(),
)?;
Ok(Box::new(pmm_dynamic::PmmDynamic::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "twap_executor",
factory: |ctx| {
let cfg =
twap_executor::TwapConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(twap_executor::TwapExecutor::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "dca_executor",
factory: |ctx| {
let cfg =
dca_executor::DcaConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(dca_executor::DcaExecutor::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
StrategyDescriptor {
name: "vwap_executor",
factory: |ctx| {
let cfg =
vwap_executor::VwapConfig::from_params(ctx.config.strategy.params.table())?;
Ok(Box::new(vwap_executor::VwapExecutor::new(
cfg,
ctx.gateway.clone(),
ctx.market.clone(),
)))
},
},
]
})
}
pub fn build_strategy(ctx: &StrategyContext) -> Result<Box<dyn Strategy>> {
let kind = if ctx.config.strategy.strategy_type.is_empty() {
"simple_grid"
} else {
ctx.config.strategy.strategy_type.as_str()
};
let descriptor = registry()
.iter()
.find(|d| d.name == kind)
.ok_or_else(|| color_eyre::eyre::eyre!("unknown strategy type: {kind}"))?;
(descriptor.factory)(ctx)
}
#[cfg(test)]
mod tests {
use std::{collections::HashSet, time::Duration};
use buffa::EnumValue;
use rust_decimal_macros::dec;
use super::*;
use crate::{adapters::MockAdapter, proto::trading, strategies::Strategy};
const ALL_PARAMS: &str = "\
symbol = \"BTC/USDT\"
exchange_id = \"mock\"
lower_price = \"90\"
upper_price = \"110\"
num_levels = 4
qty_per_level = \"0.1\"
grid_tick = \"1\"
perp_symbol = \"BTC/USDT:USDT\"
lead_symbol = \"BTC/USDT:USDT\"
lag_symbol = \"BTC/USDT\"
primary = { exchange_id = \"mock\", label = \"\" }
hedge = { exchange_id = \"mock\", label = \"\" }
asset = \"USDT\"
threshold = \"1\"
min_balance = \"100\"
repay_above = \"1000\"
from_asset = \"USDT\"
to_asset = \"USDC\"
min_amount = \"10\"
dest_label = \"futures\"
inventory_cap = \"1\"
alert_threshold = \"0.01\"
targets = { BTC = \"1\" }
weights = { BTC = \"0.6\" }
signal_file = \"/tmp/longtrader-registry-irr-signal\"
spot_symbol = \"BTC/USDT\"
total_amount = \"1\"
prices = [\"99\", \"98\", \"97\"]
amounts_quote = [\"100\", \"100\", \"100\"]
symbol_a = \"BTC/USDT\"
symbol_b = \"ETH/USDT\"
";
const GRID_ONLY_PARAMS: &str = "\
symbol = \"BTC/USDT\"
lower_price = \"90\"
upper_price = \"110\"
num_levels = 4
qty_per_level = \"0.1\"
";
fn config_of(kind: &str, params: &str) -> Config {
let doc = format!(
"daemon_endpoint = \"http://127.0.0.1:1\"\n\
[strategy]\ntype = \"{kind}\"\n\
[strategy.params]\n{params}"
);
toml::from_str(&doc).expect("the fixture config must parse")
}
fn context_over(adapter: Arc<MockAdapter>, config: Config) -> StrategyContext {
StrategyContext {
config,
gateway: Arc::clone(&adapter) as Arc<dyn TradingGateway>,
market: Arc::clone(&adapter) as Arc<dyn MarketDataSource>,
funding: Arc::clone(&adapter) as Arc<dyn FundingRateSource>,
triggers: Arc::clone(&adapter) as Arc<dyn TriggerOrderGateway>,
ops: Arc::clone(&adapter) as Arc<dyn VenueOpInvoker>,
wallet: Arc::clone(&adapter) as Arc<dyn WalletGateway>,
}
}
fn context(kind: &str) -> StrategyContext {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
context_over(adapter, config_of(kind, ALL_PARAMS))
}
fn context_with_adapter(kind: &str) -> (Arc<MockAdapter>, StrategyContext) {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
let ctx = context_over(Arc::clone(&adapter), config_of(kind, ALL_PARAMS));
(adapter, ctx)
}
fn build_error(kind: &str) {
let outcome = build_strategy(&context(kind)).err();
let rendered = match outcome {
Some(err) => format!("{err:#}"),
None => String::new(),
};
assert!(!rendered.is_empty(), "{kind} must not resolve to a strategy");
assert!(
rendered.contains(kind),
"the error must name the kind it could not build: {rendered}"
);
}
#[test]
fn every_registered_strategy_builds() {
assert!(!registry().is_empty(), "the registry must not be empty");
for descriptor in registry() {
let outcome = build_strategy(&context(descriptor.name)).err();
assert!(outcome.is_none(), "{} must build, got {outcome:?}", descriptor.name);
}
}
#[tokio::test]
async fn an_omitted_strategy_type_defaults_to_simple_grid() {
let adapter = Arc::new(MockAdapter::new(dec!(100)));
let ctx = context_over(Arc::clone(&adapter), config_of("", GRID_ONLY_PARAMS));
let strategy =
build_strategy(&ctx).expect("an omitted strategy.type must not fail startup");
let orders = orders_after_first_tick(strategy, &adapter).await;
assert!(!orders.is_empty(), "the default strategy must start quoting");
assert!(
orders.iter().all(|o| o.client_order_id.starts_with("grid-")),
"the default must be the grid, not another registered name: {:?}",
orders.iter().map(|o| &o.client_order_id).collect::<Vec<_>>()
);
assert_eq!(orders[0].r#type, EnumValue::Known(trading::OrderType::Limit));
}
#[test]
fn an_unknown_strategy_type_is_refused_and_names_the_kind() {
build_error("not-a-strategy");
}
#[test]
fn the_registry_has_no_duplicate_names() {
let mut seen = HashSet::new();
for descriptor in registry() {
assert!(seen.insert(descriptor.name), "duplicate registry name: {}", descriptor.name);
}
assert_eq!(seen.len(), registry().len(), "every entry must have a distinct name");
assert!(
seen.contains("dca") && seen.contains("dca_scheduler"),
"both DCA spellings must stay registered"
);
}
#[test]
fn every_registered_strategy_is_visible_in_the_catalog() {
let catalog = longtrader_catalog::builtin_descriptors();
let catalog_ids: HashSet<&str> = catalog.iter().map(|d| d.id.as_str()).collect();
let worker_ids: HashSet<&str> =
longtrader_catalog::WORKER_STRATEGY_IDS.into_iter().collect();
let registry_ids: HashSet<&str> = registry().iter().map(|d| d.name).collect();
assert_eq!(registry_ids, worker_ids, "registry and catalog WORKER_STRATEGY_IDS drifted");
for name in registry_ids {
assert!(
catalog_ids.contains(name),
"registry strategy {name:?} has no catalog descriptor"
);
}
}
async fn orders_after_first_tick(
strategy: Box<dyn Strategy>,
adapter: &Arc<MockAdapter>,
) -> Vec<trading::Order> {
let task = tokio::spawn(async move { strategy.run().await });
let mut placed = Vec::new();
for _ in 0..100 {
let open = adapter
.fetch_open_orders(trading::FetchOpenOrdersRequest::default())
.await
.expect("the mock must answer an open-orders read");
if !open.is_empty() {
placed = open;
break;
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
task.abort();
placed
}
#[tokio::test]
async fn the_dca_alias_behaves_identically_to_dca_scheduler() {
let (adapter_alias, ctx_alias) = context_with_adapter("dca");
let (adapter_canonical, ctx_canonical) = context_with_adapter("dca_scheduler");
let alias = build_strategy(&ctx_alias).expect("the dca alias must build");
let canonical = build_strategy(&ctx_canonical).expect("dca_scheduler must build");
let from_alias = orders_after_first_tick(alias, &adapter_alias).await;
let from_canonical = orders_after_first_tick(canonical, &adapter_canonical).await;
assert_eq!(from_alias.len(), 1, "the alias must place exactly one order");
assert_eq!(from_canonical.len(), 1, "the canonical name must place exactly one order");
for orders in [&from_alias, &from_canonical] {
assert!(
orders[0].client_order_id.starts_with("dca-"),
"both spellings must use the DCA order namespace: {}",
orders[0].client_order_id
);
assert_eq!(orders[0].side, EnumValue::Known(trading::OrderSide::Buy));
assert_eq!(orders[0].r#type, EnumValue::Known(trading::OrderType::Market));
assert_eq!(orders[0].symbol, "BTC/USDT");
}
assert_eq!(
longtrader_contract::ext::common_to_decimal(
from_alias[0].amount.as_option().expect("amount")
)
.expect("decodes"),
longtrader_contract::ext::common_to_decimal(
from_canonical[0].amount.as_option().expect("amount")
)
.expect("decodes"),
"the alias must size the same order as the canonical name"
);
}
}
#[cfg(test)]
mod catalog_sync_tests {
use super::registry;
#[test]
fn the_catalog_names_exactly_the_registry_strategies() {
let mut registry_names: Vec<&str> =
registry().iter().map(|descriptor| descriptor.name).collect();
registry_names.sort_unstable();
let mut catalog_names: Vec<&str> =
longtrader_catalog::WORKER_STRATEGY_IDS.iter().copied().collect();
catalog_names.sort_unstable();
assert_eq!(
catalog_names, registry_names,
"longtrader_catalog::WORKER_STRATEGY_IDS must mirror the registry exactly"
);
}
}