solwatch 0.1.7

Real-data Solana memecoin auditor — rug/freeze/bundle scanner with a 0-100 risk score, plain-English flags, and a live dashboard. Sister tool to Hoodwatch.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Shared audit types — wire-compatible with Hoodwatch's AuditResult shape
//! (same score/verdict/flags contract, Solana-native sections).

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Severity {
    Critical,
    Danger,
    Warning,
    Info,
    Good,
}

impl Severity {
    pub fn rank(self) -> u8 {
        match self {
            Severity::Critical => 5,
            Severity::Danger => 4,
            Severity::Warning => 3,
            Severity::Info => 2,
            Severity::Good => 1,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Flag {
    pub id: String,
    pub severity: Severity,
    pub title: String,
    pub detail: String,
    pub weight: i32,
    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
    pub hard_fail: bool,
}

impl Flag {
    pub fn new(id: &str, severity: Severity, title: &str, detail: String, weight: i32) -> Self {
        Flag {
            id: id.into(),
            severity,
            title: title.into(),
            detail,
            weight,
            hard_fail: false,
        }
    }
    pub fn hard(mut self) -> Self {
        self.hard_fail = true;
        self
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Verdict {
    Avoid,
    HighRisk,
    Caution,
    Fair,
    LowRisk,
    Unknown,
}

#[derive(Debug, Clone, Serialize, Default)]
pub struct TokenMeta {
    pub name: Option<String>,
    pub symbol: Option<String>,
    pub decimals: Option<u32>,
    #[serde(rename = "totalSupply")]
    pub total_supply: Option<String>,
    #[serde(rename = "holdersCount")]
    pub holders_count: Option<u64>,
    #[serde(rename = "marketCapUsd")]
    pub market_cap_usd: Option<f64>,
    #[serde(rename = "volume24hUsd")]
    pub volume_24h_usd: Option<f64>,
    #[serde(rename = "priceUsd")]
    pub price_usd: Option<f64>,
    #[serde(rename = "tokenProgram")]
    pub token_program: Option<String>,
    pub launchpad: Option<String>,
    #[serde(rename = "createdAt")]
    pub created_at: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct AuditResult {
    pub address: String,
    pub chain: &'static str,
    #[serde(rename = "scannedAt")]
    pub scanned_at: String,
    pub token: TokenMeta,
    pub score: i32,
    pub verdict: Verdict,
    pub flags: Vec<Flag>,
    pub sections: serde_json::Value,
    pub warnings: Vec<String>,
    /// "View this in Rokha" link — only present when the owner sets
    /// SOLWATCH_ROKHA_URL (their rig's product page). Never fabricated.
    #[serde(rename = "rokhaUrl", skip_serializing_if = "Option::is_none")]
    pub rokha_url: Option<String>,
    /// The Rokha APP-view block (title/verdict/score/metrics/sections) — a
    /// rig whose final step outputs this JSON gets a native render in Rokha's
    /// output rail, no adapter needed. Null only when the mint is unresolved.
    #[serde(
        rename = "rokha_app",
        skip_serializing_if = "serde_json::Value::is_null"
    )]
    pub rokha_app: serde_json::Value,
}

/// Fold flags into a 0-100 score + verdict (deduction model, hard-fail caps).
/// A honeypot-class flag (non-transferable / frozen-by-default / permanent
/// delegate / confiscatory transfer fee) caps the score at 5; other hard fails
/// (no liquidity) cap it at 20.
pub fn score_flags(flags: &[Flag], token_resolved: bool) -> (i32, Verdict) {
    if !token_resolved {
        return (0, Verdict::Unknown);
    }
    let mut score = 100i32;
    let mut cap = 100i32;
    for f in flags {
        score -= f.weight;
        if f.hard_fail {
            cap = cap.min(if f.severity == Severity::Critical {
                5
            } else {
                20
            });
        }
    }
    score = score.clamp(0, cap);
    let verdict = if score <= 10 {
        Verdict::Avoid
    } else if score < 40 {
        Verdict::HighRisk
    } else if score < 60 {
        Verdict::Caution
    } else if score < 80 {
        Verdict::Fair
    } else {
        Verdict::LowRisk
    };
    (score, verdict)
}