Skip to main content

vanity_core/chains/
mod.rs

1mod algorand;
2mod aptos;
3mod bitcoin_like;
4mod cardano;
5mod cosmos;
6mod evm;
7mod filecoin;
8mod hedera;
9mod icp;
10mod kaspa;
11mod kusama;
12mod multiversx;
13mod near;
14mod polkadot;
15mod ripple;
16mod solana;
17mod stellar;
18mod sui;
19mod tezos;
20mod ton;
21mod tron;
22mod util;
23
24pub use algorand::AlgorandGrinder;
25pub use aptos::AptosGrinder;
26pub use bitcoin_like::BitcoinLikeGrinder;
27pub use cardano::CardanoGrinder;
28pub use cosmos::CosmosGrinder;
29pub use evm::EvmGrinder;
30pub use filecoin::FilecoinGrinder;
31pub use hedera::HederaGrinder;
32pub use icp::IcpGrinder;
33pub use kaspa::KaspaGrinder;
34pub use kusama::KusamaGrinder;
35pub use multiversx::MultiversXGrinder;
36pub use near::NearGrinder;
37pub use polkadot::PolkadotGrinder;
38pub use ripple::RippleGrinder;
39pub use solana::SolanaGrinder;
40pub use stellar::StellarGrinder;
41pub use sui::SuiGrinder;
42pub use tezos::TezosGrinder;
43pub use ton::TonGrinder;
44pub use tron::TronGrinder;
45
46use crate::chain::{ChainGrinder, GrindAttempt, KeypairResult};
47use crate::pattern::Pattern;
48
49#[derive(Clone)]
50pub enum Chain {
51    Solana(SolanaGrinder),
52    Evm(EvmGrinder),
53    Bitcoin(BitcoinLikeGrinder),
54    Litecoin(BitcoinLikeGrinder),
55    Dogecoin(BitcoinLikeGrinder),
56    Dash(BitcoinLikeGrinder),
57    Tron(TronGrinder),
58    Cosmos(CosmosGrinder),
59    Osmosis(CosmosGrinder),
60    Ripple(RippleGrinder),
61    Stellar(StellarGrinder),
62    Aptos(AptosGrinder),
63    Sui(SuiGrinder),
64    Near(NearGrinder),
65    Algorand(AlgorandGrinder),
66    Tezos(TezosGrinder),
67    Icp(IcpGrinder),
68    Kaspa(KaspaGrinder),
69    Kusama(KusamaGrinder),
70    Ton(TonGrinder),
71    Filecoin(FilecoinGrinder),
72    Polkadot(PolkadotGrinder),
73    Cardano(CardanoGrinder),
74    Hedera(HederaGrinder),
75    MultiversX(MultiversXGrinder),
76}
77
78/// Menu label for interactive chain picker (index 0-based).
79/// Ordered A–Z by display name for easier selection.
80pub const MENU_CHAINS: [(&str, &str); 25] = [
81    ("algo", "Algorand (base32)"),
82    ("aptos", "Aptos (0x hex)"),
83    ("btc", "Bitcoin (base58 · P2PKH)"),
84    ("ada", "Cardano (enterprise addr1)"),
85    ("cosmos", "Cosmos (bech32 · ATOM)"),
86    ("dash", "Dash (base58 · P2PKH)"),
87    ("doge", "Dogecoin (base58)"),
88    ("evm", "EVM (0x hex · MetaMask)"),
89    ("fil", "Filecoin (f1 · secp256k1)"),
90    ("hedera", "Hedera (ed25519 pubkey hex)"),
91    ("icp", "Internet Computer (principal)"),
92    ("kaspa", "Kaspa (bech32)"),
93    ("ksm", "Kusama (SS58 · ed25519)"),
94    ("ltc", "Litecoin (base58 · P2PKH)"),
95    ("erd", "MultiversX (bech32 · erd1)"),
96    ("near", "NEAR (hex implicit account)"),
97    ("osmo", "Osmosis (bech32 · OSMO)"),
98    ("dot", "Polkadot (SS58 · ed25519)"),
99    ("xrp", "Ripple (base58 · r…)"),
100    ("sol", "Solana (base58 · Phantom, Solflare)"),
101    ("xlm", "Stellar (strkey · G…)"),
102    ("sui", "Sui (0x hex)"),
103    ("xtz", "Tezos (tz1 · ed25519)"),
104    ("ton", "TON (Wallet V4R2 · UQ…)"),
105    ("trx", "Tron (base58 · T…)"),
106];
107
108impl Chain {
109    pub fn from_menu_index(index: usize) -> Option<Self> {
110        match index {
111            0 => Some(Chain::Algorand(AlgorandGrinder)),
112            1 => Some(Chain::Aptos(AptosGrinder)),
113            2 => Some(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
114            3 => Some(Chain::Cardano(CardanoGrinder)),
115            4 => Some(Chain::Cosmos(CosmosGrinder::cosmos())),
116            5 => Some(Chain::Dash(BitcoinLikeGrinder::dash())),
117            6 => Some(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
118            7 => Some(Chain::Evm(EvmGrinder)),
119            8 => Some(Chain::Filecoin(FilecoinGrinder)),
120            9 => Some(Chain::Hedera(HederaGrinder)),
121            10 => Some(Chain::Icp(IcpGrinder)),
122            11 => Some(Chain::Kaspa(KaspaGrinder)),
123            12 => Some(Chain::Kusama(KusamaGrinder)),
124            13 => Some(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
125            14 => Some(Chain::MultiversX(MultiversXGrinder)),
126            15 => Some(Chain::Near(NearGrinder)),
127            16 => Some(Chain::Osmosis(CosmosGrinder::osmosis())),
128            17 => Some(Chain::Polkadot(PolkadotGrinder)),
129            18 => Some(Chain::Ripple(RippleGrinder)),
130            19 => Some(Chain::Solana(SolanaGrinder)),
131            20 => Some(Chain::Stellar(StellarGrinder)),
132            21 => Some(Chain::Sui(SuiGrinder)),
133            22 => Some(Chain::Tezos(TezosGrinder)),
134            23 => Some(Chain::Ton(TonGrinder)),
135            24 => Some(Chain::Tron(TronGrinder)),
136            _ => None,
137        }
138    }
139
140    pub fn from_id(id: &str) -> Result<Self, String> {
141        let id = id.to_ascii_lowercase();
142        match id.as_str() {
143            "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
144            "evm" | "eth" | "ethereum" => Ok(Chain::Evm(EvmGrinder)),
145            "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
146            "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
147            "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
148            "dash" => Ok(Chain::Dash(BitcoinLikeGrinder::dash())),
149            "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
150            "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
151            "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
152            "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
153            "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
154            "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
155            "sui" => Ok(Chain::Sui(SuiGrinder)),
156            "near" => Ok(Chain::Near(NearGrinder)),
157            "algo" | "algorand" => Ok(Chain::Algorand(AlgorandGrinder)),
158            "xtz" | "tezos" => Ok(Chain::Tezos(TezosGrinder)),
159            "icp" | "internet-computer" | "dfinity" => Ok(Chain::Icp(IcpGrinder)),
160            "kaspa" | "kas" => Ok(Chain::Kaspa(KaspaGrinder)),
161            "ksm" | "kusama" => Ok(Chain::Kusama(KusamaGrinder)),
162            "ton" => Ok(Chain::Ton(TonGrinder)),
163            "fil" | "filecoin" => Ok(Chain::Filecoin(FilecoinGrinder)),
164            "dot" | "polkadot" | "substrate" => Ok(Chain::Polkadot(PolkadotGrinder)),
165            "ada" | "cardano" => Ok(Chain::Cardano(CardanoGrinder)),
166            "hedera" | "hbar" => Ok(Chain::Hedera(HederaGrinder)),
167            "erd" | "mvx" | "elrond" | "multiversx" => Ok(Chain::MultiversX(MultiversXGrinder)),
168            _ => Err(format!(
169                "Unknown chain '{id}'. Supported: {}",
170                Self::supported_ids_display()
171            )),
172        }
173    }
174
175    /// Chain IDs in the same A–Z menu order.
176    pub fn all_ids() -> &'static [&'static str] {
177        &[
178            "algo", "aptos", "btc", "ada", "cosmos", "dash", "doge", "evm", "fil", "hedera", "icp",
179            "kaspa", "ksm", "ltc", "erd", "near", "osmo", "dot", "xrp", "sol", "xlm", "sui", "xtz",
180            "ton", "trx",
181        ]
182    }
183
184    fn supported_ids_display() -> String {
185        Self::all_ids().join(", ")
186    }
187}
188
189#[cfg(test)]
190mod tests {
191    use super::Chain;
192    use crate::chain::ChainGrinder;
193
194    #[test]
195    fn all_menu_chains_resolve_and_grind() {
196        assert_eq!(super::MENU_CHAINS.len(), 25);
197        assert_eq!(Chain::all_ids().len(), 25);
198        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
199            let chain = Chain::from_menu_index(i).expect("menu index");
200            assert_eq!(chain.id(), *id);
201            let via_id = Chain::from_id(id).expect("from_id");
202            assert_eq!(via_id.id(), *id);
203            let (addr, attempt) = chain.grind_attempt();
204            assert!(!addr.is_empty(), "{id} empty address");
205            let finalized = chain.finalize(attempt);
206            assert_eq!(finalized.address, addr, "{id} finalize mismatch");
207            assert!(!finalized.exports.is_empty(), "{id} missing exports");
208        }
209    }
210
211    /// Documents/asserts the invariant that `from_menu_index` and
212    /// `MENU_CHAINS` must stay in lockstep: for every index i,
213    /// `from_menu_index(i).id() == MENU_CHAINS[i].0`.
214    #[test]
215    fn from_menu_index_matches_menu_chains_order() {
216        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
217            let chain = Chain::from_menu_index(i).expect("menu index");
218            assert_eq!(
219                chain.id(),
220                *id,
221                "from_menu_index({i}) misaligned with MENU_CHAINS"
222            );
223        }
224        assert!(Chain::from_menu_index(super::MENU_CHAINS.len()).is_none());
225    }
226
227    #[test]
228    fn menu_chains_sorted_a_to_z_by_label() {
229        let labels: Vec<&str> = super::MENU_CHAINS.iter().map(|(_, label)| *label).collect();
230        let mut sorted = labels.clone();
231        sorted.sort_by(|a, b| a.to_ascii_lowercase().cmp(&b.to_ascii_lowercase()));
232        assert_eq!(labels, sorted, "MENU_CHAINS must stay A–Z by display name");
233        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
234            assert_eq!(Chain::all_ids()[i], *id);
235        }
236    }
237}
238
239macro_rules! dispatch {
240    ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
241        match $self {
242            Chain::Solana(g) => g.$method($($arg),*),
243            Chain::Evm(g) => g.$method($($arg),*),
244            Chain::Bitcoin(g) => g.$method($($arg),*),
245            Chain::Litecoin(g) => g.$method($($arg),*),
246            Chain::Dogecoin(g) => g.$method($($arg),*),
247            Chain::Dash(g) => g.$method($($arg),*),
248            Chain::Tron(g) => g.$method($($arg),*),
249            Chain::Cosmos(g) => g.$method($($arg),*),
250            Chain::Osmosis(g) => g.$method($($arg),*),
251            Chain::Ripple(g) => g.$method($($arg),*),
252            Chain::Stellar(g) => g.$method($($arg),*),
253            Chain::Aptos(g) => g.$method($($arg),*),
254            Chain::Sui(g) => g.$method($($arg),*),
255            Chain::Near(g) => g.$method($($arg),*),
256            Chain::Algorand(g) => g.$method($($arg),*),
257            Chain::Tezos(g) => g.$method($($arg),*),
258            Chain::Icp(g) => g.$method($($arg),*),
259            Chain::Kaspa(g) => g.$method($($arg),*),
260            Chain::Kusama(g) => g.$method($($arg),*),
261            Chain::Ton(g) => g.$method($($arg),*),
262            Chain::Filecoin(g) => g.$method($($arg),*),
263            Chain::Polkadot(g) => g.$method($($arg),*),
264            Chain::Cardano(g) => g.$method($($arg),*),
265            Chain::Hedera(g) => g.$method($($arg),*),
266            Chain::MultiversX(g) => g.$method($($arg),*),
267        }
268    };
269}
270
271impl ChainGrinder for Chain {
272    fn id(&self) -> &'static str {
273        dispatch!(self, id())
274    }
275
276    fn display_name(&self) -> &'static str {
277        dispatch!(self, display_name())
278    }
279
280    fn grind_attempt(&self) -> (String, GrindAttempt) {
281        dispatch!(self, grind_attempt())
282    }
283
284    fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
285        dispatch!(self, finalize(attempt))
286    }
287
288    fn build_pattern(
289        &self,
290        prefix: Option<&str>,
291        suffix: Option<&str>,
292        exact: bool,
293    ) -> Result<Pattern, String> {
294        dispatch!(self, build_pattern(prefix, suffix, exact))
295    }
296
297    fn expected_attempts(&self, pattern: &Pattern) -> f64 {
298        dispatch!(self, expected_attempts(pattern))
299    }
300
301    fn matches(&self, address: &str, pattern: &Pattern) -> bool {
302        dispatch!(self, matches(address, pattern))
303    }
304
305    fn supports_exact_case(&self) -> bool {
306        dispatch!(self, supports_exact_case())
307    }
308
309    fn pattern_hint(&self) -> &'static str {
310        dispatch!(self, pattern_hint())
311    }
312}