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