sim-cli 0.2.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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use std::{
    collections::{BTreeMap, HashMap, HashSet},
    path::PathBuf,
};

use chrono::{DateTime, Utc};
use clap::Parser;
use console::style;
use eyre::{Context, Result};

use crate::output::SimulationOutput;

#[derive(Parser, Debug)]
pub struct SummarizeArgs {
    /// Simulation output file to summarize
    pub file: PathBuf,
    /// Comma-separated list of wallet addresses to trace balances across all transactions
    #[arg(long, value_delimiter = ',')]
    pub accounts: Vec<String>,
}

// Opening and closing balance for one token/SOL across the full simulation run.
struct BalanceTrace {
    opening: u64,
    closing: u64,
    decimals: u8,
}

pub fn summarize(args: SummarizeArgs) -> Result<()> {
    let json = std::fs::read_to_string(&args.file)
        .with_context(|| format!("failed to read {}", args.file.display()))?;
    let output: SimulationOutput = serde_json::from_str(&json).with_context(|| {
        format!(
            "failed to parse {} as simulation output",
            args.file.display()
        )
    })?;

    let m = &output.metadata;
    println!("File         : {}", args.file.display());
    println!("Slot range   : {} → {}", m.start_slot, m.end_slot);
    if !m.program_ids.is_empty() {
        println!("Program IDs  : {}", m.program_ids.join(", "));
    }
    if !m.program_so.is_empty() {
        println!("Program.so   : {}", m.program_so.join(", "));
    }
    println!("Session(s)   : {}", m.session_ids.len());
    let ran_at = DateTime::<Utc>::from_timestamp(m.ran_at_unix_secs as i64, 0)
        .map(|dt| dt.format("%Y-%m-%d %H:%M:%S UTC").to_string())
        .unwrap_or_else(|| format!("{} (unix)", m.ran_at_unix_secs));
    println!("Ran at       : {ran_at}");
    println!();

    let s = &output.summary;
    println!(
        "{} Transactions : {}  ({} successes, {} failures)",
        style("i").blue(),
        s.total_transactions,
        s.successes,
        s.failures,
    );

    if args.accounts.is_empty() {
        return Ok(());
    }

    let tracked: HashSet<&str> = args.accounts.iter().map(|s| s.as_str()).collect();

    // Per wallet: "SOL" or mint -> BalanceTrace
    // Transactions are already in slot order, so the first pre we see is the opening
    // balance and we keep overwriting closing with the latest post.
    let mut traces: HashMap<&str, BTreeMap<String, BalanceTrace>> =
        tracked.iter().map(|a| (*a, BTreeMap::new())).collect();

    for tx in &output.transactions {
        for sc in &tx.sol_changes {
            if let Some(wallet) = tracked.get(sc.pubkey.as_str()) {
                let entry = traces
                    .get_mut(wallet)
                    .unwrap()
                    .entry("SOL".to_string())
                    .or_insert(BalanceTrace {
                        opening: sc.pre_lamports,
                        closing: sc.post_lamports,
                        decimals: 9,
                    });
                entry.closing = sc.post_lamports;
            }
        }

        for tc in &tx.token_changes {
            if let Some(wallet) = tracked.get(tc.owner.as_str()) {
                let entry = traces
                    .get_mut(wallet)
                    .unwrap()
                    .entry(tc.mint.clone())
                    .or_insert(BalanceTrace {
                        opening: tc.pre_amount,
                        closing: tc.post_amount,
                        decimals: tc.decimals,
                    });
                entry.closing = tc.post_amount;
            }
        }
    }

    println!();
    for account in &args.accounts {
        println!("Account: {account}");
        let wallet_traces = &traces[account.as_str()];
        if wallet_traces.is_empty() {
            println!("  (no activity found)");
        }
        for (label, t) in wallet_traces {
            let dec = t.decimals as usize;
            let div = 10u64.pow(t.decimals as u32) as f64;
            let open = t.opening as f64 / div;
            let close = t.closing as f64 / div;
            let delta = close - open;
            println!("  {label:<50}  {open:.dec$} → {close:.dec$}  (Δ {delta:+.dec$})");
        }
        println!();
    }

    Ok(())
}