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