#![allow(missing_docs, missing_debug_implementations)]
use std::sync::Arc;
use clap::Parser;
use color_eyre::{Result, eyre::bail};
use longtrader_worker::{
adapters::{MockAdapter, RemoteAdapter},
config::Config,
ports::{
FundingRateSource, MarketDataSource, TradingGateway, TriggerOrderGateway, VenueOpInvoker,
WalletGateway,
},
risk::RiskGateway,
session::{Capabilities, SessionManager},
strategies::{self, StrategyContext},
};
const DEFAULT_ENDPOINT: &str = "http://127.0.0.1:8810";
const CONTROL_PLANE_SHUTDOWN_GRACE: std::time::Duration = std::time::Duration::from_secs(10);
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Cli {
#[arg(short, long)]
config: String,
}
#[tokio::main]
#[hotpath::main]
async fn main() -> Result<()> {
color_eyre::install()?;
tracing_subscriber::fmt()
.with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
.init();
let cli = Cli::parse();
let config = Config::load(&cli.config)?;
let backend = config.validated_backend()?.to_string();
tracing::info!(
backend = %backend,
strategy = %config.strategy.strategy_type,
"starting worker"
);
let token = config.api_token()?;
match backend.as_str() {
"mock" => {
let mock = Arc::new(MockAdapter::new(rust_decimal::Decimal::from(95_000)));
tracing::info!("using MockAdapter (offline dry-run)");
start_with_ports(
mock.clone(),
mock.clone(),
mock.clone(),
mock.clone(),
mock.clone(),
mock.clone(),
&config,
token.as_str(),
)
.await
}
"api" => {
let endpoint = config.endpoint_or_default(DEFAULT_ENDPOINT);
let adapter = Arc::new(RemoteAdapter::new(&endpoint, token.as_str()));
tracing::info!(endpoint = %endpoint, "connected to backend");
start_with(adapter, &config, token.as_str()).await
}
other => bail!("unknown backend: {other} (expected 'mock' or 'api')"),
}
}
async fn start_with(adapter: Arc<RemoteAdapter>, config: &Config, token: &str) -> Result<()> {
let gateway: Arc<dyn TradingGateway> = adapter.clone();
let market: Arc<dyn MarketDataSource> = adapter.clone();
let funding: Arc<dyn FundingRateSource> = adapter.clone();
let triggers: Arc<dyn TriggerOrderGateway> = adapter.clone();
let ops: Arc<dyn VenueOpInvoker> = adapter.clone();
let wallet: Arc<dyn WalletGateway> = adapter.clone();
start_with_ports(gateway, market, funding, triggers, ops, wallet, config, token).await
}
fn report_capabilities(strategy: &str, caps: &Capabilities) {
const NEEDS: &[(&str, &str)] = &[
("xfunding_lite", "funding rates"),
("premium_monitor", "funding rates"),
("autoborrow", "venue ops"),
("convert", "venue ops"),
("deposit_transfer", "wallet"),
("balance_align", "wallet"),
];
for (name, capability) in NEEDS {
if *name != strategy {
continue;
}
let available = match *capability {
"funding rates" => caps.funding.is_some(),
"venue ops" => caps.ops.is_some(),
"wallet" => caps.wallet.is_some(),
other => {
tracing::error!(
capability = other,
"unknown capability name in report_capabilities"
);
false
}
};
if available {
tracing::info!(strategy = %strategy, capability = %capability, "capability available");
} else {
tracing::warn!(
strategy = %strategy,
capability = %capability,
"backend does not serve this capability; affected RPCs will answer unimplemented"
);
}
}
}
#[allow(clippy::too_many_arguments)]
async fn start_with_ports(
gateway: Arc<dyn TradingGateway>,
market: Arc<dyn MarketDataSource>,
funding: Arc<dyn FundingRateSource>,
triggers: Arc<dyn TriggerOrderGateway>,
ops: Arc<dyn VenueOpInvoker>,
wallet: Arc<dyn WalletGateway>,
config: &Config,
token: &str,
) -> Result<()> {
let limits = config.risk.limits();
let gateway: Arc<dyn TradingGateway> = if limits.is_enabled() {
tracing::info!(?limits, "pre-trade risk gate enabled");
Arc::new(RiskGateway::new(gateway, limits))
} else {
gateway
};
let ctx = StrategyContext {
config: config.clone(),
gateway: gateway.clone(),
market: market.clone(),
funding: funding.clone(),
triggers: triggers.clone(),
ops: ops.clone(),
wallet: wallet.clone(),
};
let strategy = strategies::build_strategy(&ctx)?;
let capabilities = Capabilities {
funding: Some(funding.clone()),
triggers: Some(triggers.clone()),
wallet: Some(wallet.clone()),
ops: Some(ops.clone()),
};
report_capabilities(&config.strategy.strategy_type, &capabilities);
if let Some(bind) = &config.listen_endpoint {
let token = token.to_string();
let exchange_id = longtrader_worker::ports::exchange_id(
config.strategy.params.venue(),
config.strategy.params.venue_label(),
);
let manager = SessionManager::new(
if token.is_empty() { None } else { Some(token) },
exchange_id,
gateway,
market,
)
.with_capabilities(capabilities);
let manager = Arc::new(manager);
manager.install_self().await;
let bind = bind.clone();
let (shutdown_tx, shutdown_rx) = tokio::sync::oneshot::channel::<()>();
let mut server_handle = tokio::spawn(async move {
let shutdown = async move {
let _ = shutdown_rx.await;
};
if let Err(err) = longtrader_worker::session::server::run(bind, manager, shutdown).await
{
tracing::error!(error = %err, "control plane server exited");
}
});
let outcome = tokio::select! {
result = drive_strategy(strategy.as_ref()) => result,
signal = tokio::signal::ctrl_c() => {
match signal {
Ok(()) => tracing::info!("shutdown signal received; stopping strategy"),
Err(err) => tracing::warn!(error = %err, "shutdown signal handler failed"),
}
strategy.stop().await
}
};
let _ = shutdown_tx.send(());
if tokio::time::timeout(CONTROL_PLANE_SHUTDOWN_GRACE, &mut server_handle).await.is_err() {
server_handle.abort();
}
outcome
} else {
drive_strategy(strategy.as_ref()).await
}
}
async fn drive_strategy(strategy: &dyn strategies::Strategy) -> Result<()> {
strategy.start().await?;
let result = strategy.run().await;
strategy.stop().await?;
result
}