Skip to main content

vanity_core/chains/
mod.rs

1mod aptos;
2mod bitcoin_like;
3mod cosmos;
4mod evm;
5mod near;
6mod ripple;
7mod solana;
8mod stellar;
9mod sui;
10mod tron;
11mod util;
12
13pub use aptos::AptosGrinder;
14pub use bitcoin_like::BitcoinLikeGrinder;
15pub use cosmos::CosmosGrinder;
16pub use evm::EvmGrinder;
17pub use near::NearGrinder;
18pub use ripple::RippleGrinder;
19pub use solana::SolanaGrinder;
20pub use stellar::StellarGrinder;
21pub use sui::SuiGrinder;
22pub use tron::TronGrinder;
23
24use crate::chain::{ChainGrinder, GrindAttempt, KeypairResult};
25use crate::pattern::Pattern;
26
27#[derive(Clone)]
28pub enum Chain {
29    Solana(SolanaGrinder),
30    Evm(EvmGrinder),
31    Bitcoin(BitcoinLikeGrinder),
32    Litecoin(BitcoinLikeGrinder),
33    Dogecoin(BitcoinLikeGrinder),
34    Tron(TronGrinder),
35    Cosmos(CosmosGrinder),
36    Osmosis(CosmosGrinder),
37    Ripple(RippleGrinder),
38    Stellar(StellarGrinder),
39    Aptos(AptosGrinder),
40    Sui(SuiGrinder),
41    Near(NearGrinder),
42}
43
44/// Menu label for interactive chain picker (index 0-based).
45pub const MENU_CHAINS: [(&str, &str); 13] = [
46    ("sol", "Solana (base58 · Phantom, Solflare)"),
47    ("evm", "EVM (0x hex · MetaMask)"),
48    ("btc", "Bitcoin (base58 · P2PKH)"),
49    ("ltc", "Litecoin (base58 · P2PKH)"),
50    ("doge", "Dogecoin (base58)"),
51    ("trx", "Tron (base58 · T…)"),
52    ("cosmos", "Cosmos (bech32 · ATOM)"),
53    ("osmo", "Osmosis (bech32 · OSMO)"),
54    ("xrp", "Ripple (base58 · r…)"),
55    ("xlm", "Stellar (strkey · G…)"),
56    ("aptos", "Aptos (0x hex)"),
57    ("sui", "Sui (0x hex)"),
58    ("near", "NEAR (hex implicit account)"),
59];
60
61impl Chain {
62    pub fn from_menu_index(index: usize) -> Option<Self> {
63        match index {
64            0 => Some(Chain::Solana(SolanaGrinder)),
65            1 => Some(Chain::Evm(EvmGrinder)),
66            2 => Some(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
67            3 => Some(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
68            4 => Some(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
69            5 => Some(Chain::Tron(TronGrinder)),
70            6 => Some(Chain::Cosmos(CosmosGrinder::cosmos())),
71            7 => Some(Chain::Osmosis(CosmosGrinder::osmosis())),
72            8 => Some(Chain::Ripple(RippleGrinder)),
73            9 => Some(Chain::Stellar(StellarGrinder)),
74            10 => Some(Chain::Aptos(AptosGrinder)),
75            11 => Some(Chain::Sui(SuiGrinder)),
76            12 => Some(Chain::Near(NearGrinder)),
77            _ => None,
78        }
79    }
80
81    pub fn from_id(id: &str) -> Result<Self, String> {
82        let id = id.to_ascii_lowercase();
83        match id.as_str() {
84            "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
85            "evm" | "eth" | "ethereum" => Ok(Chain::Evm(EvmGrinder)),
86            "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
87            "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
88            "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
89            "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
90            "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
91            "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
92            "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
93            "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
94            "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
95            "sui" => Ok(Chain::Sui(SuiGrinder)),
96            "near" => Ok(Chain::Near(NearGrinder)),
97            _ => Err(format!(
98                "Unknown chain '{id}'. Supported: {}",
99                Self::supported_ids_display()
100            )),
101        }
102    }
103
104    pub fn all_ids() -> &'static [&'static str] {
105        &[
106            "sol", "evm", "btc", "ltc", "doge", "trx", "cosmos", "osmo", "xrp", "xlm", "aptos",
107            "sui", "near",
108        ]
109    }
110
111    fn supported_ids_display() -> String {
112        Self::all_ids().join(", ")
113    }
114}
115
116macro_rules! dispatch {
117    ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
118        match $self {
119            Chain::Solana(g) => g.$method($($arg),*),
120            Chain::Evm(g) => g.$method($($arg),*),
121            Chain::Bitcoin(g) => g.$method($($arg),*),
122            Chain::Litecoin(g) => g.$method($($arg),*),
123            Chain::Dogecoin(g) => g.$method($($arg),*),
124            Chain::Tron(g) => g.$method($($arg),*),
125            Chain::Cosmos(g) => g.$method($($arg),*),
126            Chain::Osmosis(g) => g.$method($($arg),*),
127            Chain::Ripple(g) => g.$method($($arg),*),
128            Chain::Stellar(g) => g.$method($($arg),*),
129            Chain::Aptos(g) => g.$method($($arg),*),
130            Chain::Sui(g) => g.$method($($arg),*),
131            Chain::Near(g) => g.$method($($arg),*),
132        }
133    };
134}
135
136impl ChainGrinder for Chain {
137    fn id(&self) -> &'static str {
138        dispatch!(self, id())
139    }
140
141    fn display_name(&self) -> &'static str {
142        dispatch!(self, display_name())
143    }
144
145    fn grind_attempt(&self) -> (String, GrindAttempt) {
146        dispatch!(self, grind_attempt())
147    }
148
149    fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
150        dispatch!(self, finalize(attempt))
151    }
152
153    fn build_pattern(
154        &self,
155        prefix: Option<&str>,
156        suffix: Option<&str>,
157        exact: bool,
158    ) -> Result<Pattern, String> {
159        dispatch!(self, build_pattern(prefix, suffix, exact))
160    }
161
162    fn expected_attempts(&self, pattern: &Pattern) -> f64 {
163        dispatch!(self, expected_attempts(pattern))
164    }
165
166    fn matches(&self, address: &str, pattern: &Pattern) -> bool {
167        dispatch!(self, matches(address, pattern))
168    }
169
170    fn supports_exact_case(&self) -> bool {
171        dispatch!(self, supports_exact_case())
172    }
173
174    fn pattern_hint(&self) -> &'static str {
175        dispatch!(self, pattern_hint())
176    }
177}