Skip to main content

vanity_core/chains/
mod.rs

1mod algorand;
2mod aptos;
3mod bitcoin_like;
4mod bitcoin_segwit;
5mod cardano;
6mod cosmos;
7pub mod create2;
8mod evm;
9mod evm_contract;
10mod filecoin;
11mod hedera;
12mod icp;
13mod kaspa;
14mod kusama;
15mod multiversx;
16mod near;
17mod polkadot;
18mod ripple;
19mod solana;
20mod stellar;
21mod sui;
22mod tezos;
23mod ton;
24mod tron;
25mod util;
26
27pub use algorand::AlgorandGrinder;
28pub use aptos::AptosGrinder;
29pub use bitcoin_like::BitcoinLikeGrinder;
30pub use bitcoin_segwit::BitcoinSegwitGrinder;
31pub use cardano::CardanoGrinder;
32pub use cosmos::CosmosGrinder;
33pub use create2::Create2Grinder;
34pub use evm::EvmGrinder;
35pub use evm_contract::EvmContractGrinder;
36pub use filecoin::FilecoinGrinder;
37pub use hedera::HederaGrinder;
38pub use icp::IcpGrinder;
39pub use kaspa::KaspaGrinder;
40pub use kusama::KusamaGrinder;
41pub use multiversx::MultiversXGrinder;
42pub use near::NearGrinder;
43pub use polkadot::PolkadotGrinder;
44pub use ripple::RippleGrinder;
45pub use solana::{SolanaGrinder, SolanaMintGrinder};
46pub use stellar::StellarGrinder;
47pub use sui::SuiGrinder;
48pub use tezos::TezosGrinder;
49pub use ton::TonGrinder;
50pub use tron::TronGrinder;
51
52use crate::chain::{ChainGrinder, GrindAttempt, KeypairResult};
53use crate::pattern::Pattern;
54
55#[derive(Clone)]
56pub enum Chain {
57    Solana(SolanaGrinder),
58    Evm(EvmGrinder),
59    Bitcoin(BitcoinLikeGrinder),
60    BitcoinSegwit(BitcoinSegwitGrinder),
61    BitcoinTaproot(BitcoinSegwitGrinder),
62    Litecoin(BitcoinLikeGrinder),
63    Dogecoin(BitcoinLikeGrinder),
64    Dash(BitcoinLikeGrinder),
65    Tron(TronGrinder),
66    Cosmos(CosmosGrinder),
67    Osmosis(CosmosGrinder),
68    Sei(CosmosGrinder),
69    Injective(CosmosGrinder),
70    Celestia(CosmosGrinder),
71    Dydx(CosmosGrinder),
72    Ripple(RippleGrinder),
73    Stellar(StellarGrinder),
74    Aptos(AptosGrinder),
75    Sui(SuiGrinder),
76    Near(NearGrinder),
77    Algorand(AlgorandGrinder),
78    Tezos(TezosGrinder),
79    Icp(IcpGrinder),
80    Kaspa(KaspaGrinder),
81    Kusama(KusamaGrinder),
82    Ton(TonGrinder),
83    Filecoin(FilecoinGrinder),
84    Polkadot(PolkadotGrinder),
85    Cardano(CardanoGrinder),
86    Hedera(HederaGrinder),
87    MultiversX(MultiversXGrinder),
88    Create2(Create2Grinder),
89    EvmContract(EvmContractGrinder),
90    SolanaMint(SolanaMintGrinder),
91}
92
93/// Menu label for interactive chain picker (index 0-based).
94/// Ordered A–Z by display name for easier selection.
95pub const MENU_CHAINS: [(&str, &str); 31] = [
96    ("algo", "Algorand (base32)"),
97    ("aptos", "Aptos (0x hex)"),
98    ("btc", "Bitcoin (base58 · P2PKH)"),
99    ("btc-segwit", "Bitcoin SegWit (bc1q · P2WPKH)"),
100    ("btc-taproot", "Bitcoin Taproot (bc1p)"),
101    ("ada", "Cardano (enterprise addr1)"),
102    ("tia", "Celestia (bech32 · TIA)"),
103    ("cosmos", "Cosmos (bech32 · ATOM)"),
104    ("dash", "Dash (base58 · P2PKH)"),
105    ("doge", "Dogecoin (base58)"),
106    ("dydx", "dYdX (bech32)"),
107    ("evm", "EVM (0x hex · MetaMask / Base / Robinhood…)"),
108    ("fil", "Filecoin (f1 · secp256k1)"),
109    ("hedera", "Hedera (ed25519 pubkey hex)"),
110    ("inj", "Injective (bech32 · INJ)"),
111    ("icp", "Internet Computer (principal)"),
112    ("kaspa", "Kaspa (bech32)"),
113    ("ksm", "Kusama (SS58 · ed25519)"),
114    ("ltc", "Litecoin (base58 · P2PKH)"),
115    ("erd", "MultiversX (bech32 · erd1)"),
116    ("near", "NEAR (hex implicit account)"),
117    ("osmo", "Osmosis (bech32 · OSMO)"),
118    ("dot", "Polkadot (SS58 · ed25519)"),
119    ("xrp", "Ripple (base58 · r…)"),
120    ("sei", "Sei (bech32 · SEI)"),
121    ("sol", "Solana (base58 · Phantom, Solflare)"),
122    ("xlm", "Stellar (strkey · G…)"),
123    ("sui", "Sui (0x hex)"),
124    ("xtz", "Tezos (tz1 · ed25519)"),
125    ("ton", "TON (Wallet V4R2 · UQ…)"),
126    ("trx", "Tron (base58 · T…)"),
127];
128
129impl Chain {
130    pub fn from_menu_index(index: usize) -> Option<Self> {
131        match index {
132            0 => Some(Chain::Algorand(AlgorandGrinder)),
133            1 => Some(Chain::Aptos(AptosGrinder)),
134            2 => Some(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
135            3 => Some(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit())),
136            4 => Some(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot())),
137            5 => Some(Chain::Cardano(CardanoGrinder)),
138            6 => Some(Chain::Celestia(CosmosGrinder::celestia())),
139            7 => Some(Chain::Cosmos(CosmosGrinder::cosmos())),
140            8 => Some(Chain::Dash(BitcoinLikeGrinder::dash())),
141            9 => Some(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
142            10 => Some(Chain::Dydx(CosmosGrinder::dydx())),
143            11 => Some(Chain::Evm(EvmGrinder)),
144            12 => Some(Chain::Filecoin(FilecoinGrinder)),
145            13 => Some(Chain::Hedera(HederaGrinder)),
146            14 => Some(Chain::Injective(CosmosGrinder::injective())),
147            15 => Some(Chain::Icp(IcpGrinder)),
148            16 => Some(Chain::Kaspa(KaspaGrinder)),
149            17 => Some(Chain::Kusama(KusamaGrinder)),
150            18 => Some(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
151            19 => Some(Chain::MultiversX(MultiversXGrinder)),
152            20 => Some(Chain::Near(NearGrinder)),
153            21 => Some(Chain::Osmosis(CosmosGrinder::osmosis())),
154            22 => Some(Chain::Polkadot(PolkadotGrinder)),
155            23 => Some(Chain::Ripple(RippleGrinder)),
156            24 => Some(Chain::Sei(CosmosGrinder::sei())),
157            25 => Some(Chain::Solana(SolanaGrinder)),
158            26 => Some(Chain::Stellar(StellarGrinder)),
159            27 => Some(Chain::Sui(SuiGrinder)),
160            28 => Some(Chain::Tezos(TezosGrinder)),
161            29 => Some(Chain::Ton(TonGrinder)),
162            30 => Some(Chain::Tron(TronGrinder)),
163            _ => None,
164        }
165    }
166
167    pub fn from_id(id: &str) -> Result<Self, String> {
168        let id = id.to_ascii_lowercase();
169        match id.as_str() {
170            "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
171            "sol-mint" | "spl-mint" | "mint" => Ok(Chain::SolanaMint(SolanaMintGrinder)),
172            // EVM + trending L2 / app-chain aliases (same address math)
173            "evm" | "eth" | "ethereum" | "base" | "arb" | "arbitrum" | "op" | "optimism"
174            | "polygon" | "matic" | "avax" | "avalanche" | "bnb" | "bsc" | "fantom" | "ftm"
175            | "scroll" | "linea" | "zksync" | "blast" | "mantle" | "mode" | "bera"
176            | "berachain" | "monad" | "abstract" | "unichain" | "robinhood" | "hood" | "rh"
177            | "hyperliquid" | "hyperevm" | "hype" | "sonic" => Ok(Chain::Evm(EvmGrinder)),
178            "evm-contract" | "evm-create" | "contract" => {
179                Ok(Chain::EvmContract(EvmContractGrinder))
180            }
181            "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
182            "btc-segwit" | "segwit" | "bc1q" => {
183                Ok(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit()))
184            }
185            "btc-taproot" | "taproot" | "bc1p" => {
186                Ok(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot()))
187            }
188            "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
189            "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
190            "dash" => Ok(Chain::Dash(BitcoinLikeGrinder::dash())),
191            "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
192            "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
193            "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
194            "sei" => Ok(Chain::Sei(CosmosGrinder::sei())),
195            "inj" | "injective" => Ok(Chain::Injective(CosmosGrinder::injective())),
196            "tia" | "celestia" => Ok(Chain::Celestia(CosmosGrinder::celestia())),
197            "dydx" => Ok(Chain::Dydx(CosmosGrinder::dydx())),
198            "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
199            "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
200            "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
201            "sui" => Ok(Chain::Sui(SuiGrinder)),
202            "near" => Ok(Chain::Near(NearGrinder)),
203            "algo" | "algorand" => Ok(Chain::Algorand(AlgorandGrinder)),
204            "xtz" | "tezos" => Ok(Chain::Tezos(TezosGrinder)),
205            "icp" | "internet-computer" | "dfinity" => Ok(Chain::Icp(IcpGrinder)),
206            "kaspa" | "kas" => Ok(Chain::Kaspa(KaspaGrinder)),
207            "ksm" | "kusama" => Ok(Chain::Kusama(KusamaGrinder)),
208            "ton" => Ok(Chain::Ton(TonGrinder)),
209            "fil" | "filecoin" => Ok(Chain::Filecoin(FilecoinGrinder)),
210            "dot" | "polkadot" | "substrate" => Ok(Chain::Polkadot(PolkadotGrinder)),
211            "ada" | "cardano" => Ok(Chain::Cardano(CardanoGrinder)),
212            "hedera" | "hbar" => Ok(Chain::Hedera(HederaGrinder)),
213            "erd" | "mvx" | "elrond" | "multiversx" => Ok(Chain::MultiversX(MultiversXGrinder)),
214            _ => Err(format!(
215                "Unknown chain '{id}'. Supported: {} (deploy modes: evm-contract, sol-mint)",
216                Self::supported_ids_display()
217            )),
218        }
219    }
220
221    /// Chain IDs in the same A–Z menu order.
222    pub fn all_ids() -> &'static [&'static str] {
223        &[
224            "algo",
225            "aptos",
226            "btc",
227            "btc-segwit",
228            "btc-taproot",
229            "ada",
230            "tia",
231            "cosmos",
232            "dash",
233            "doge",
234            "dydx",
235            "evm",
236            "fil",
237            "hedera",
238            "inj",
239            "icp",
240            "kaspa",
241            "ksm",
242            "ltc",
243            "erd",
244            "near",
245            "osmo",
246            "dot",
247            "xrp",
248            "sei",
249            "sol",
250            "xlm",
251            "sui",
252            "xtz",
253            "ton",
254            "trx",
255        ]
256    }
257
258    fn supported_ids_display() -> String {
259        Self::all_ids().join(", ")
260    }
261}
262
263macro_rules! dispatch {
264    ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
265        match $self {
266            Chain::Solana(g) => g.$method($($arg),*),
267            Chain::Evm(g) => g.$method($($arg),*),
268            Chain::Bitcoin(g) => g.$method($($arg),*),
269            Chain::BitcoinSegwit(g) => g.$method($($arg),*),
270            Chain::BitcoinTaproot(g) => g.$method($($arg),*),
271            Chain::Litecoin(g) => g.$method($($arg),*),
272            Chain::Dogecoin(g) => g.$method($($arg),*),
273            Chain::Dash(g) => g.$method($($arg),*),
274            Chain::Tron(g) => g.$method($($arg),*),
275            Chain::Cosmos(g) => g.$method($($arg),*),
276            Chain::Osmosis(g) => g.$method($($arg),*),
277            Chain::Sei(g) => g.$method($($arg),*),
278            Chain::Injective(g) => g.$method($($arg),*),
279            Chain::Celestia(g) => g.$method($($arg),*),
280            Chain::Dydx(g) => g.$method($($arg),*),
281            Chain::Ripple(g) => g.$method($($arg),*),
282            Chain::Stellar(g) => g.$method($($arg),*),
283            Chain::Aptos(g) => g.$method($($arg),*),
284            Chain::Sui(g) => g.$method($($arg),*),
285            Chain::Near(g) => g.$method($($arg),*),
286            Chain::Algorand(g) => g.$method($($arg),*),
287            Chain::Tezos(g) => g.$method($($arg),*),
288            Chain::Icp(g) => g.$method($($arg),*),
289            Chain::Kaspa(g) => g.$method($($arg),*),
290            Chain::Kusama(g) => g.$method($($arg),*),
291            Chain::Ton(g) => g.$method($($arg),*),
292            Chain::Filecoin(g) => g.$method($($arg),*),
293            Chain::Polkadot(g) => g.$method($($arg),*),
294            Chain::Cardano(g) => g.$method($($arg),*),
295            Chain::Hedera(g) => g.$method($($arg),*),
296            Chain::MultiversX(g) => g.$method($($arg),*),
297            Chain::Create2(g) => g.$method($($arg),*),
298            Chain::EvmContract(g) => g.$method($($arg),*),
299            Chain::SolanaMint(g) => g.$method($($arg),*),
300        }
301    };
302}
303
304impl ChainGrinder for Chain {
305    fn id(&self) -> &'static str {
306        dispatch!(self, id())
307    }
308
309    fn display_name(&self) -> &'static str {
310        dispatch!(self, display_name())
311    }
312
313    fn grind_attempt(&self) -> (String, GrindAttempt) {
314        dispatch!(self, grind_attempt())
315    }
316
317    fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
318        dispatch!(self, finalize(attempt))
319    }
320
321    fn build_pattern(
322        &self,
323        prefix: Option<&str>,
324        suffix: Option<&str>,
325        contains: Option<&str>,
326        exact: bool,
327    ) -> Result<Pattern, String> {
328        dispatch!(self, build_pattern(prefix, suffix, contains, exact))
329    }
330
331    fn expected_attempts(&self, pattern: &Pattern) -> f64 {
332        dispatch!(self, expected_attempts(pattern))
333    }
334
335    fn matches(&self, address: &str, pattern: &Pattern) -> bool {
336        dispatch!(self, matches(address, pattern))
337    }
338
339    fn supports_exact_case(&self) -> bool {
340        dispatch!(self, supports_exact_case())
341    }
342
343    fn pattern_hint(&self) -> &'static str {
344        dispatch!(self, pattern_hint())
345    }
346}
347
348#[cfg(test)]
349mod tests {
350    use super::Chain;
351    use crate::chain::ChainGrinder;
352
353    #[test]
354    fn all_menu_chains_resolve_and_grind() {
355        assert_eq!(super::MENU_CHAINS.len(), 31);
356        assert_eq!(Chain::all_ids().len(), 31);
357        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
358            let chain = Chain::from_menu_index(i).expect("menu index");
359            assert_eq!(chain.id(), *id);
360            let via_id = Chain::from_id(id).expect("from_id");
361            assert_eq!(via_id.id(), *id);
362            let (addr, attempt) = chain.grind_attempt();
363            assert!(!addr.is_empty(), "{id} empty address");
364            let finalized = chain.finalize(attempt);
365            assert_eq!(finalized.address, addr, "{id} finalize mismatch");
366            assert!(!finalized.exports.is_empty(), "{id} missing exports");
367        }
368    }
369
370    #[test]
371    fn from_menu_index_matches_menu_chains_order() {
372        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
373            let chain = Chain::from_menu_index(i).expect("menu index");
374            assert_eq!(
375                chain.id(),
376                *id,
377                "from_menu_index({i}) misaligned with MENU_CHAINS"
378            );
379        }
380        assert!(Chain::from_menu_index(super::MENU_CHAINS.len()).is_none());
381    }
382
383    #[test]
384    fn menu_chains_sorted_a_to_z_by_label() {
385        let labels: Vec<&str> = super::MENU_CHAINS.iter().map(|(_, label)| *label).collect();
386        let mut sorted = labels.clone();
387        sorted.sort_by_key(|a| a.to_ascii_lowercase());
388        assert_eq!(labels, sorted, "MENU_CHAINS must stay A–Z by display name");
389        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
390            assert_eq!(Chain::all_ids()[i], *id);
391        }
392    }
393
394    #[test]
395    fn evm_trending_aliases_resolve() {
396        for id in [
397            "robinhood",
398            "hood",
399            "base",
400            "arb",
401            "optimism",
402            "polygon",
403            "avax",
404            "bnb",
405            "monad",
406            "hyperliquid",
407            "hyperevm",
408            "sonic",
409        ] {
410            let c = Chain::from_id(id).unwrap_or_else(|e| panic!("{id}: {e}"));
411            assert_eq!(c.id(), "evm");
412        }
413    }
414
415    #[test]
416    fn deploy_modes_resolve_and_roundtrip() {
417        for (alias, id) in [
418            ("evm-contract", "evm-contract"),
419            ("contract", "evm-contract"),
420            ("sol-mint", "sol-mint"),
421            ("mint", "sol-mint"),
422        ] {
423            let chain = Chain::from_id(alias).unwrap_or_else(|e| panic!("{alias}: {e}"));
424            assert_eq!(chain.id(), id);
425            let (addr, attempt) = chain.grind_attempt();
426            assert_eq!(chain.finalize(attempt).address, addr);
427        }
428    }
429}