solana-tools-lite-cli 0.1.1

CLI for solana-tools-lite: offline-first Solana signer toolkit.
Documentation 
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

//! Presentation rules for transaction signing summaries.

use crate::flows::presenter::{emit_line, Presentable};
use crate::shell::error::CliError;
use crate::constants::LAMPORTS_PER_SOL;
use solana_tools_lite::constants::compute_budget;
use solana_tools_lite::models::analysis::{AnalysisWarning, TokenProgramKind, TxAnalysis};

/// Bundles analysis and an optional JSON summary payload.
pub(crate) struct SignTxPresentation<'a> {
    pub(crate) analysis: Option<&'a TxAnalysis>,
    pub(crate) summary_payload: Option<&'a str>,
}

impl Presentable for SignTxPresentation<'_> {
    fn present(
        &self,
        json: bool,
        _show_secret: bool,
        to_stderr: bool,
    ) -> Result<(), CliError> {
        if let Some(analysis) = self.analysis {
            emit_summary(analysis);
        }
        
        if json {
            if let Some(payload) = self.summary_payload {
                emit_line(payload, to_stderr);
            }
        }
        Ok(())
    }
}

fn lamports_to_sol(lamports: u128) -> f64 {
    lamports as f64 / LAMPORTS_PER_SOL
}

fn emit_summary(analysis: &TxAnalysis) {
    for (i, t) in analysis.transfers.iter().enumerate() {
        eprintln!("Instruction #{}: System Program (Transfer)", i + 1);
        eprintln!(
            "  From:   {}{}",
            t.from,
            if t.from_is_signer { " (signer)" } else { "" }
        );
        eprintln!("  To:     {}", t.to);
        eprintln!("  Amount: {:.9} SOL", lamports_to_sol(t.lamports as u128));
        eprintln!("          ({} lamports)", t.lamports);
    }

    eprintln!("--------------------------------------------------");
    eprintln!("TRANSACTION SUMMARY");
    eprintln!(
        "Network Fee:    {:.9} SOL ({} lamports)",
        lamports_to_sol(analysis.base_fee_lamports),
        analysis.base_fee_lamports
    );
    if let Some((pf, est)) = analysis.priority_fee_lamports {
        if est {
            eprintln!(
                "Priority Fee:   {:.9} SOL ({} lamports, estimated with default {} CU)",
                lamports_to_sol(pf),
                pf,
                compute_budget::DEFAULT_COMPUTE_UNIT_LIMIT
            );
        } else {
            eprintln!(
                "Priority Fee:   {:.9} SOL ({} lamports)",
                lamports_to_sol(pf),
                pf
            );
        }
    } else {
        eprintln!("Priority Fee:   0.000000000 SOL (0 lamports)");
    }
    if let Some(price) = analysis.compute_unit_price_micro {
        let limit = analysis
            .compute_unit_limit
            .unwrap_or(compute_budget::DEFAULT_COMPUTE_UNIT_LIMIT);
        eprintln!(
            "Compute Budget: price={} micro-lamports, limit={}",
            price, limit
        );
    }
    let total_cost = analysis.total_fee_lamports + analysis.total_send_by_signer;
    if analysis.total_send_by_signer > 0 {
        eprintln!(
            "YOU SEND:       {:.9} SOL ({} lamports)",
            lamports_to_sol(analysis.total_send_by_signer),
            analysis.total_send_by_signer
        );
    }
    eprintln!("MAX TOTAL COST: {:.9} SOL", lamports_to_sol(total_cost));
    eprintln!("--------------------------------------------------");
    if !analysis.warnings.is_empty() {
        eprintln!("WARNINGS:");
        for w in &analysis.warnings {
            eprintln!("- {}", warning_to_message(w));
        }
        eprintln!("--------------------------------------------------");
    }
}

fn warning_to_message(warning: &AnalysisWarning) -> String {
    match warning {
        AnalysisWarning::LookupTablesNotProvided => {
            "Address table lookups present but --tables was not provided; looked-up accounts will be shown as raw indexes".to_string()
        }
        AnalysisWarning::LookupTableMissing(key) => {
            format!("Lookup table {} missing or incomplete; some accounts may be unresolved", key)
        }
        AnalysisWarning::TokenTransferDetected(kind) => {
            let label = match kind {
                TokenProgramKind::SplToken => "Token Program",
                TokenProgramKind::Token2022 => "Token-2022 Program",
            };
            format!(
                "{} transfer detected; amounts are shown as raw u64 (offline mode cannot infer decimals)",
                label
            )
        }
        AnalysisWarning::UnknownProgram { program_id } => {
            format!("Unknown program encountered: {}", program_id)
        }
    }
}