sim-cli 0.6.0

CLI tool for running and comparing Solana simulator backtests
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use chrono::{DateTime, Utc};
use clap::Parser;
use eyre::{Result, WrapErr};
use simulator_client::BacktestClient;

#[derive(Parser, Debug)]
pub struct UsageArgs {
    /// Report window start (RFC 3339 or YYYY-MM-DD). Defaults to the server's configured window.
    #[arg(long)]
    pub since: Option<String>,

    /// Report window end (RFC 3339 or YYYY-MM-DD). Defaults to now.
    #[arg(long)]
    pub until: Option<String>,

    /// Print output as JSON
    #[arg(long)]
    pub json: bool,
}

pub async fn usage(args: UsageArgs, url: String, api_key: String) -> Result<()> {
    let since = args
        .since
        .as_deref()
        .map(parse_datetime)
        .transpose()
        .wrap_err("invalid --since")?;
    let until = args
        .until
        .as_deref()
        .map(parse_datetime)
        .transpose()
        .wrap_err("invalid --until")?;

    let client = BacktestClient::builder()
        .url(format!("wss://{url}/backtest"))
        .api_key(api_key)
        .build();

    let report = client.usage(since, until).await?;

    if args.json {
        println!("{}", serde_json::to_string_pretty(&report)?);
        return Ok(());
    }

    println!("Usage Report");
    println!("  API key:      {}", report.api_key_name);
    println!(
        "  Time range:   {} to {}",
        report.since.format("%Y-%m-%d %H:%M:%S UTC"),
        report.until.format("%Y-%m-%d %H:%M:%S UTC"),
    );
    println!();
    println!("Sessions");
    println!("  Completed:  {}", report.sessions.completed);
    println!("  Incomplete: {}", report.sessions.failed);
    println!();
    println!("Compute");
    println!(
        "  Slots executed:         {}",
        report.compute.executed_slot_count
    );
    let total_mins = report.compute.session_duration_ms / 60_000;
    println!(
        "  Total session duration: {}h {}m",
        total_mins / 60,
        total_mins % 60,
    );

    Ok(())
}

fn parse_datetime(s: &str) -> Result<DateTime<Utc>> {
    // Try RFC 3339 first, then date-only (YYYY-MM-DD interpreted as midnight UTC).
    if let Ok(dt) = DateTime::parse_from_rfc3339(s) {
        return Ok(dt.with_timezone(&Utc));
    }
    let date = chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
        .wrap_err_with(|| format!("cannot parse '{s}' as RFC 3339 or YYYY-MM-DD"))?;
    Ok(date.and_hms_opt(0, 0, 0).unwrap().and_utc())
}