use anyhow::Result;
use clap::{Parser, ValueEnum};
use hft_core::{avm, config, onchain, pev, sor};
use tracing::info;
use tracing_subscriber::EnvFilter;
#[derive(Debug, Clone, ValueEnum)]
enum Mode {
Full,
Pev,
Sor,
Signer,
Reactor,
}
#[derive(Parser, Debug)]
#[command(name = "hft-core")]
#[command(about = "Optimal HFT platform using Rig (ARC) - mAI (๐ง )")]
struct Args {
#[arg(short, long, default_value = "full")]
mode: Mode,
#[arg(long, default_value_t = false)]
skip_llm: bool,
#[arg(long, default_value_t = false)]
live: bool,
#[arg(short, long, default_value = "SOL/USDC")]
pair: String,
#[arg(short, long, default_value_t = 1.0)]
amount: f64,
}
#[tokio::main]
async fn main() -> Result<()> {
dotenvy::dotenv().ok();
tracing_subscriber::fmt()
.with_env_filter(EnvFilter::from_default_env().add_directive("hft_core=debug".parse()?))
.init();
let args = Args::parse();
let mut cfg = config::Config::from_env()?;
if args.skip_llm {
cfg.skip_llm = true;
}
info!("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ");
info!("โ mAI RIG HFT ยท Rig (ARC) Platform โ");
info!("โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ");
info!(
mode = ?args.mode,
pair = %args.pair,
amount = args.amount,
live = args.live,
skip_llm = cfg.skip_llm,
"Starting platform"
);
if cfg.skip_llm {
info!("โ LLM stub mode active - PEV phases will use offline stubs.");
info!(" Set ANTHROPIC_API_KEY or omit --skip-llm for live LLM execution.");
}
match args.mode {
Mode::Full => {
let pev_result = pev::run(&cfg, &args.pair, args.amount).await?;
info!(score = pev_result.verify_score, "PEV loop complete");
let route = sor::best_route(&args.pair, args.amount).await?;
info!(
venue = %route.venue,
price = route.effective_price,
fee_bps = route.fee_bps,
latency_ms = route.latency_ms,
"SOR: best route selected"
);
let swap_result = onchain::execute_swap(&cfg, &route, args.live).await?;
info!(tx_sig = %swap_result.simulated_sig, "Swap simulation complete");
avm::audit_log(&route, &swap_result)?;
}
Mode::Pev => {
pev::run(&cfg, &args.pair, args.amount).await?;
}
Mode::Sor => {
sor::best_route(&args.pair, args.amount).await?;
}
Mode::Signer => {
onchain::demo_signer(&cfg).await?;
}
Mode::Reactor => {
avm::run_benchmark()?;
}
}
info!("Platform run complete. All operations logged.");
Ok(())
}