Skip to main content

vanity_core/chains/
mod.rs

1mod algorand;
2mod aptos;
3mod base58_odds;
4mod bitcoin_like;
5mod bitcoin_segwit;
6mod cardano;
7mod cosmos;
8pub mod create2;
9mod evm;
10mod evm_contract;
11mod filecoin;
12mod hedera;
13mod icp;
14mod kaspa;
15mod kusama;
16mod multiversx;
17mod near;
18mod polkadot;
19mod ripple;
20mod solana;
21mod stellar;
22mod sui;
23mod tezos;
24mod ton;
25mod tron;
26mod util;
27
28pub use algorand::AlgorandGrinder;
29pub use aptos::AptosGrinder;
30pub use bitcoin_like::BitcoinLikeGrinder;
31pub use bitcoin_segwit::BitcoinSegwitGrinder;
32pub use cardano::CardanoGrinder;
33pub use cosmos::CosmosGrinder;
34pub use create2::Create2Grinder;
35pub use evm::EvmGrinder;
36pub use evm_contract::EvmContractGrinder;
37pub use filecoin::FilecoinGrinder;
38pub use hedera::HederaGrinder;
39pub use icp::IcpGrinder;
40pub use kaspa::KaspaGrinder;
41pub use kusama::KusamaGrinder;
42pub use multiversx::MultiversXGrinder;
43pub use near::NearGrinder;
44pub use polkadot::PolkadotGrinder;
45pub use ripple::RippleGrinder;
46pub use solana::{SolanaGrinder, SolanaMintGrinder};
47pub use stellar::StellarGrinder;
48pub use sui::SuiGrinder;
49pub use tezos::TezosGrinder;
50pub use ton::TonGrinder;
51pub use tron::TronGrinder;
52
53use crate::chain::{ChainGrinder, GrindAttempt, KeypairResult};
54use crate::pattern::Pattern;
55
56#[derive(Clone)]
57pub enum Chain {
58    Solana(SolanaGrinder),
59    Evm(EvmGrinder),
60    Bitcoin(BitcoinLikeGrinder),
61    BitcoinSegwit(BitcoinSegwitGrinder),
62    BitcoinTaproot(BitcoinSegwitGrinder),
63    Litecoin(BitcoinLikeGrinder),
64    Dogecoin(BitcoinLikeGrinder),
65    Dash(BitcoinLikeGrinder),
66    Tron(TronGrinder),
67    Cosmos(CosmosGrinder),
68    Osmosis(CosmosGrinder),
69    Sei(CosmosGrinder),
70    Injective(CosmosGrinder),
71    Celestia(CosmosGrinder),
72    Dydx(CosmosGrinder),
73    Ripple(RippleGrinder),
74    Stellar(StellarGrinder),
75    Aptos(AptosGrinder),
76    Sui(SuiGrinder),
77    Near(NearGrinder),
78    Algorand(AlgorandGrinder),
79    Tezos(TezosGrinder),
80    Icp(IcpGrinder),
81    Kaspa(KaspaGrinder),
82    Kusama(KusamaGrinder),
83    Ton(TonGrinder),
84    Filecoin(FilecoinGrinder),
85    Polkadot(PolkadotGrinder),
86    Cardano(CardanoGrinder),
87    Hedera(HederaGrinder),
88    MultiversX(MultiversXGrinder),
89    Create2(Create2Grinder),
90    EvmContract(EvmContractGrinder),
91    SolanaMint(SolanaMintGrinder),
92}
93
94/// Menu label for interactive chain picker (index 0-based).
95/// Ordered A–Z by display name for easier selection.
96pub const MENU_CHAINS: [(&str, &str); 31] = [
97    ("algo", "Algorand (base32)"),
98    ("aptos", "Aptos (0x hex)"),
99    ("btc", "Bitcoin (base58 · P2PKH)"),
100    ("btc-segwit", "Bitcoin SegWit (bc1q · P2WPKH)"),
101    ("btc-taproot", "Bitcoin Taproot (bc1p)"),
102    ("ada", "Cardano (enterprise addr1)"),
103    ("tia", "Celestia (bech32 · TIA)"),
104    ("cosmos", "Cosmos (bech32 · ATOM)"),
105    ("dash", "Dash (base58 · P2PKH)"),
106    ("doge", "Dogecoin (base58)"),
107    ("dydx", "dYdX (bech32)"),
108    ("evm", "EVM (0x hex · MetaMask / Base / Robinhood…)"),
109    ("fil", "Filecoin (f1 · secp256k1)"),
110    ("hedera", "Hedera (ed25519 pubkey hex)"),
111    ("inj", "Injective (bech32 · INJ)"),
112    ("icp", "Internet Computer (principal)"),
113    ("kaspa", "Kaspa (bech32)"),
114    ("ksm", "Kusama (SS58 · ed25519)"),
115    ("ltc", "Litecoin (base58 · P2PKH)"),
116    ("erd", "MultiversX (bech32 · erd1)"),
117    ("near", "NEAR (hex implicit account)"),
118    ("osmo", "Osmosis (bech32 · OSMO)"),
119    ("dot", "Polkadot (SS58 · ed25519)"),
120    ("xrp", "Ripple (base58 · r…)"),
121    ("sei", "Sei (bech32 · SEI)"),
122    ("sol", "Solana (base58 · Phantom, Solflare)"),
123    ("xlm", "Stellar (strkey · G…)"),
124    ("sui", "Sui (0x hex)"),
125    ("xtz", "Tezos (tz1 · ed25519)"),
126    ("ton", "TON (Wallet V4R2 · UQ…)"),
127    ("trx", "Tron (base58 · T…)"),
128];
129
130impl Chain {
131    /// How many characters one pattern position can match, i.e. how much longer
132    /// each extra character makes a grind. Any-case base58/base64 letters match two.
133    pub fn chars_per_position(&self, ignore_case: bool) -> f64 {
134        match self.id() {
135            "evm" | "evm-contract" | "create2" | "aptos" | "sui" | "near" | "hedera" => 16.0,
136            "ton" if ignore_case => 37.0,
137            "ton" => 64.0,
138            "sol" | "sol-mint" | "btc" | "ltc" | "doge" | "dash" | "trx" | "xrp" | "dot"
139            | "ksm" | "xtz" => {
140                // Typical letter: both cases in base58 → 58/2. (i/o/L are one-case; digits stay 58.)
141                if ignore_case {
142                    29.0
143                } else {
144                    58.0
145                }
146            }
147            _ => 32.0,
148        }
149    }
150
151    pub fn from_menu_index(index: usize) -> Option<Self> {
152        match index {
153            0 => Some(Chain::Algorand(AlgorandGrinder)),
154            1 => Some(Chain::Aptos(AptosGrinder)),
155            2 => Some(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
156            3 => Some(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit())),
157            4 => Some(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot())),
158            5 => Some(Chain::Cardano(CardanoGrinder)),
159            6 => Some(Chain::Celestia(CosmosGrinder::celestia())),
160            7 => Some(Chain::Cosmos(CosmosGrinder::cosmos())),
161            8 => Some(Chain::Dash(BitcoinLikeGrinder::dash())),
162            9 => Some(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
163            10 => Some(Chain::Dydx(CosmosGrinder::dydx())),
164            11 => Some(Chain::Evm(EvmGrinder)),
165            12 => Some(Chain::Filecoin(FilecoinGrinder)),
166            13 => Some(Chain::Hedera(HederaGrinder)),
167            14 => Some(Chain::Injective(CosmosGrinder::injective())),
168            15 => Some(Chain::Icp(IcpGrinder)),
169            16 => Some(Chain::Kaspa(KaspaGrinder)),
170            17 => Some(Chain::Kusama(KusamaGrinder)),
171            18 => Some(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
172            19 => Some(Chain::MultiversX(MultiversXGrinder)),
173            20 => Some(Chain::Near(NearGrinder)),
174            21 => Some(Chain::Osmosis(CosmosGrinder::osmosis())),
175            22 => Some(Chain::Polkadot(PolkadotGrinder)),
176            23 => Some(Chain::Ripple(RippleGrinder)),
177            24 => Some(Chain::Sei(CosmosGrinder::sei())),
178            25 => Some(Chain::Solana(SolanaGrinder)),
179            26 => Some(Chain::Stellar(StellarGrinder)),
180            27 => Some(Chain::Sui(SuiGrinder)),
181            28 => Some(Chain::Tezos(TezosGrinder)),
182            29 => Some(Chain::Ton(TonGrinder)),
183            30 => Some(Chain::Tron(TronGrinder)),
184            _ => None,
185        }
186    }
187
188    pub fn from_id(id: &str) -> Result<Self, String> {
189        let id = id.to_ascii_lowercase();
190        match id.as_str() {
191            "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
192            "sol-mint" | "spl-mint" | "mint" => Ok(Chain::SolanaMint(SolanaMintGrinder)),
193            // EVM + trending L2 / app-chain aliases (same address math)
194            "evm" | "eth" | "ethereum" | "base" | "arb" | "arbitrum" | "op" | "optimism"
195            | "polygon" | "matic" | "avax" | "avalanche" | "bnb" | "bsc" | "fantom" | "ftm"
196            | "scroll" | "linea" | "zksync" | "blast" | "mantle" | "mode" | "bera"
197            | "berachain" | "monad" | "abstract" | "unichain" | "robinhood" | "hood" | "rh"
198            | "hyperliquid" | "hyperevm" | "hype" | "sonic" => Ok(Chain::Evm(EvmGrinder)),
199            "evm-contract" | "evm-create" | "contract" => {
200                Ok(Chain::EvmContract(EvmContractGrinder))
201            }
202            "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
203            "btc-segwit" | "segwit" | "bc1q" => {
204                Ok(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit()))
205            }
206            "btc-taproot" | "taproot" | "bc1p" => {
207                Ok(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot()))
208            }
209            "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
210            "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
211            "dash" => Ok(Chain::Dash(BitcoinLikeGrinder::dash())),
212            "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
213            "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
214            "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
215            "sei" => Ok(Chain::Sei(CosmosGrinder::sei())),
216            "inj" | "injective" => Ok(Chain::Injective(CosmosGrinder::injective())),
217            "tia" | "celestia" => Ok(Chain::Celestia(CosmosGrinder::celestia())),
218            "dydx" => Ok(Chain::Dydx(CosmosGrinder::dydx())),
219            "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
220            "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
221            "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
222            "sui" => Ok(Chain::Sui(SuiGrinder)),
223            "near" => Ok(Chain::Near(NearGrinder)),
224            "algo" | "algorand" => Ok(Chain::Algorand(AlgorandGrinder)),
225            "xtz" | "tezos" => Ok(Chain::Tezos(TezosGrinder)),
226            "icp" | "internet-computer" | "dfinity" => Ok(Chain::Icp(IcpGrinder)),
227            "kaspa" | "kas" => Ok(Chain::Kaspa(KaspaGrinder)),
228            "ksm" | "kusama" => Ok(Chain::Kusama(KusamaGrinder)),
229            "ton" => Ok(Chain::Ton(TonGrinder)),
230            "fil" | "filecoin" => Ok(Chain::Filecoin(FilecoinGrinder)),
231            "dot" | "polkadot" | "substrate" => Ok(Chain::Polkadot(PolkadotGrinder)),
232            "ada" | "cardano" => Ok(Chain::Cardano(CardanoGrinder)),
233            "hedera" | "hbar" => Ok(Chain::Hedera(HederaGrinder)),
234            "erd" | "mvx" | "elrond" | "multiversx" => Ok(Chain::MultiversX(MultiversXGrinder)),
235            _ => Err(format!(
236                "Unknown chain '{id}'. Supported: {} (deploy modes: evm-contract, sol-mint)",
237                Self::supported_ids_display()
238            )),
239        }
240    }
241
242    /// Chain IDs in the same A–Z menu order.
243    pub fn all_ids() -> &'static [&'static str] {
244        &[
245            "algo",
246            "aptos",
247            "btc",
248            "btc-segwit",
249            "btc-taproot",
250            "ada",
251            "tia",
252            "cosmos",
253            "dash",
254            "doge",
255            "dydx",
256            "evm",
257            "fil",
258            "hedera",
259            "inj",
260            "icp",
261            "kaspa",
262            "ksm",
263            "ltc",
264            "erd",
265            "near",
266            "osmo",
267            "dot",
268            "xrp",
269            "sei",
270            "sol",
271            "xlm",
272            "sui",
273            "xtz",
274            "ton",
275            "trx",
276        ]
277    }
278
279    fn supported_ids_display() -> String {
280        Self::all_ids().join(", ")
281    }
282}
283
284macro_rules! dispatch {
285    ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
286        match $self {
287            Chain::Solana(g) => g.$method($($arg),*),
288            Chain::Evm(g) => g.$method($($arg),*),
289            Chain::Bitcoin(g) => g.$method($($arg),*),
290            Chain::BitcoinSegwit(g) => g.$method($($arg),*),
291            Chain::BitcoinTaproot(g) => g.$method($($arg),*),
292            Chain::Litecoin(g) => g.$method($($arg),*),
293            Chain::Dogecoin(g) => g.$method($($arg),*),
294            Chain::Dash(g) => g.$method($($arg),*),
295            Chain::Tron(g) => g.$method($($arg),*),
296            Chain::Cosmos(g) => g.$method($($arg),*),
297            Chain::Osmosis(g) => g.$method($($arg),*),
298            Chain::Sei(g) => g.$method($($arg),*),
299            Chain::Injective(g) => g.$method($($arg),*),
300            Chain::Celestia(g) => g.$method($($arg),*),
301            Chain::Dydx(g) => g.$method($($arg),*),
302            Chain::Ripple(g) => g.$method($($arg),*),
303            Chain::Stellar(g) => g.$method($($arg),*),
304            Chain::Aptos(g) => g.$method($($arg),*),
305            Chain::Sui(g) => g.$method($($arg),*),
306            Chain::Near(g) => g.$method($($arg),*),
307            Chain::Algorand(g) => g.$method($($arg),*),
308            Chain::Tezos(g) => g.$method($($arg),*),
309            Chain::Icp(g) => g.$method($($arg),*),
310            Chain::Kaspa(g) => g.$method($($arg),*),
311            Chain::Kusama(g) => g.$method($($arg),*),
312            Chain::Ton(g) => g.$method($($arg),*),
313            Chain::Filecoin(g) => g.$method($($arg),*),
314            Chain::Polkadot(g) => g.$method($($arg),*),
315            Chain::Cardano(g) => g.$method($($arg),*),
316            Chain::Hedera(g) => g.$method($($arg),*),
317            Chain::MultiversX(g) => g.$method($($arg),*),
318            Chain::Create2(g) => g.$method($($arg),*),
319            Chain::EvmContract(g) => g.$method($($arg),*),
320            Chain::SolanaMint(g) => g.$method($($arg),*),
321        }
322    };
323}
324
325impl ChainGrinder for Chain {
326    fn id(&self) -> &'static str {
327        dispatch!(self, id())
328    }
329
330    fn display_name(&self) -> &'static str {
331        dispatch!(self, display_name())
332    }
333
334    fn grind_attempt(&self) -> (String, GrindAttempt) {
335        dispatch!(self, grind_attempt())
336    }
337
338    fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
339        dispatch!(self, finalize(attempt))
340    }
341
342    fn build_pattern(
343        &self,
344        prefix: Option<&str>,
345        suffix: Option<&str>,
346        contains: Option<&str>,
347        exact: bool,
348    ) -> Result<Pattern, String> {
349        dispatch!(self, build_pattern(prefix, suffix, contains, exact))
350    }
351
352    fn expected_attempts(&self, pattern: &Pattern) -> f64 {
353        dispatch!(self, expected_attempts(pattern))
354    }
355
356    fn matches(&self, address: &str, pattern: &Pattern) -> bool {
357        dispatch!(self, matches(address, pattern))
358    }
359
360    fn supports_exact_case(&self) -> bool {
361        dispatch!(self, supports_exact_case())
362    }
363
364    fn pattern_hint(&self) -> &'static str {
365        dispatch!(self, pattern_hint())
366    }
367}
368
369#[cfg(test)]
370mod tests {
371    use super::Chain;
372    use crate::chain::ChainGrinder;
373
374    #[test]
375    fn all_menu_chains_resolve_and_grind() {
376        assert_eq!(super::MENU_CHAINS.len(), 31);
377        assert_eq!(Chain::all_ids().len(), 31);
378        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
379            let chain = Chain::from_menu_index(i).expect("menu index");
380            assert_eq!(chain.id(), *id);
381            let via_id = Chain::from_id(id).expect("from_id");
382            assert_eq!(via_id.id(), *id);
383            let (addr, attempt) = chain.grind_attempt();
384            assert!(!addr.is_empty(), "{id} empty address");
385            let finalized = chain.finalize(attempt);
386            assert_eq!(finalized.address, addr, "{id} finalize mismatch");
387            assert!(!finalized.exports.is_empty(), "{id} missing exports");
388        }
389    }
390
391    #[test]
392    fn from_menu_index_matches_menu_chains_order() {
393        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
394            let chain = Chain::from_menu_index(i).expect("menu index");
395            assert_eq!(
396                chain.id(),
397                *id,
398                "from_menu_index({i}) misaligned with MENU_CHAINS"
399            );
400        }
401        assert!(Chain::from_menu_index(super::MENU_CHAINS.len()).is_none());
402    }
403
404    #[test]
405    fn menu_chains_sorted_a_to_z_by_label() {
406        let labels: Vec<&str> = super::MENU_CHAINS.iter().map(|(_, label)| *label).collect();
407        let mut sorted = labels.clone();
408        sorted.sort_by_key(|a| a.to_ascii_lowercase());
409        assert_eq!(labels, sorted, "MENU_CHAINS must stay A–Z by display name");
410        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
411            assert_eq!(Chain::all_ids()[i], *id);
412        }
413    }
414
415    #[test]
416    fn evm_trending_aliases_resolve() {
417        for id in [
418            "robinhood",
419            "hood",
420            "base",
421            "arb",
422            "optimism",
423            "polygon",
424            "avax",
425            "bnb",
426            "monad",
427            "hyperliquid",
428            "hyperevm",
429            "sonic",
430        ] {
431            let c = Chain::from_id(id).unwrap_or_else(|e| panic!("{id}: {e}"));
432            assert_eq!(c.id(), "evm");
433        }
434    }
435
436    #[test]
437    fn chain_forced_prefix_is_not_counted_as_difficulty() {
438        for (id, input) in [
439            ("evm", "ab"),
440            ("evm-contract", "ab"),
441            ("kaspa", "pq"),
442            ("cosmos", "qp"),
443            ("sei", "qp"),
444            ("btc-segwit", "qp"),
445            ("btc-taproot", "qp"),
446            ("ada", "8x"),
447            ("erd", "qp"),
448            ("ton", "ab"),
449            ("xlm", "ab"),
450            ("xtz", "ab"),
451            ("fil", "ab"),
452            ("btc", "ab"),
453            ("ltc", "ab"),
454            ("doge", "ab"),
455            ("dash", "ph"),
456            ("trx", "ab"),
457            ("xrp", "ab"),
458            ("dot", "ab"),
459        ] {
460            let chain = Chain::from_id(id).unwrap();
461            let p = chain
462                .build_pattern(Some(input), None, None, false)
463                .unwrap_or_else(|e| panic!("{id} {input}: {e}"));
464            assert_eq!(
465                p.effective_literal_chars(),
466                2,
467                "{id} '{input}' → '{}'",
468                p.prefix
469            );
470            let est = crate::grind_estimate(chain.expected_attempts(&p), 500_000.0, &p);
471            assert_eq!(est.risk, crate::PatternRisk::None, "{id} '{input}'");
472        }
473    }
474
475    #[test]
476    fn impossible_address_starts_are_rejected() {
477        for (id, input) in [
478            ("kaspa", "ax"),
479            ("ada", "ax"),
480            ("ada", "va"),
481            ("ton", "zz"),
482            ("xlm", "XY"),
483            ("xlm", "GZ"),
484            ("doge", "z"),
485            ("ltc", "1"),
486            ("dash", "1"),
487            ("trx", "1"),
488            ("xtz", "1"),
489            ("ksm", "a"),
490        ] {
491            let chain = Chain::from_id(id).unwrap();
492            let err = chain
493                .build_pattern(Some(input), None, None, false)
494                .expect_err(&format!("{id} '{input}' should be rejected"));
495            assert!(err.contains("can never"), "{id} '{input}': {err}");
496        }
497    }
498
499    #[test]
500    fn constrained_start_lowers_expected_attempts() {
501        let chain = Chain::from_id("kaspa").unwrap();
502        let p = chain.build_pattern(Some("qp"), None, None, false).unwrap();
503        assert_eq!(p.prefix, "kaspa:qp");
504        // `q` is certain, `p` is 1 of 4 → about 4 tries, not 32².
505        assert!((chain.expected_attempts(&p) - 4.0).abs() < 1e-9);
506
507        let btc = Chain::from_id("btc").unwrap();
508        let p = btc.build_pattern(Some("1ab"), None, None, false).unwrap();
509        assert_eq!(p.prefix, "1ab");
510        assert_eq!(p.effective_literal_chars(), 2);
511
512        // Doge is `D` + one of 24 characters, so `Da` takes ~24 tries, not 58.
513        let doge = Chain::from_id("doge").unwrap();
514        let p = doge.build_pattern(Some("A"), None, None, true).unwrap();
515        let tries = doge.expected_attempts(&p);
516        assert!((20.0..30.0).contains(&tries), "doge 'A' → {tries}");
517    }
518
519    #[test]
520    fn ambiguous_lead_picks_the_reading_that_exists() {
521        // `D1` can't follow the `D` lead, so it must mean `DD1…`.
522        for (id, input, want) in [
523            ("doge", "D1", "DD1"),
524            ("trx", "T1", "TT1"),
525            ("ltc", "L1", "LL1"),
526            ("kaspa", "q0", "kaspa:qq0"),
527            ("kaspa", "qp", "kaspa:qp"),
528            ("ada", "8", "addr1v8"),
529            ("btc", "1ab", "1ab"),
530        ] {
531            let chain = Chain::from_id(id).unwrap();
532            let p = chain.build_pattern(Some(input), None, None, true).unwrap();
533            assert_eq!(p.prefix, want, "{id} '{input}'");
534        }
535    }
536
537    /// Every real address must be reachable: the start of a freshly generated
538    /// address is never rejected and the resulting pattern matches it.
539    #[test]
540    fn real_address_starts_are_always_accepted() {
541        let mut ids: Vec<&str> = Chain::all_ids().to_vec();
542        ids.extend(["evm-contract", "sol-mint"]);
543        for id in ids {
544            let chain = Chain::from_id(id).unwrap();
545            let addrs: Vec<String> = (0..300).map(|_| chain.grind_attempt().0).collect();
546            let fixed = (0..addrs[0].len())
547                .take_while(|&i| {
548                    addrs
549                        .iter()
550                        .all(|a| a.as_bytes()[i] == addrs[0].as_bytes()[i])
551                })
552                .count();
553            for a in &addrs {
554                for k in 1..=3 {
555                    let input = &a[fixed..fixed + k];
556                    for exact in [true, false] {
557                        let p = chain
558                            .build_pattern(Some(input), None, None, exact)
559                            .unwrap_or_else(|e| panic!("{id} '{input}' (from {a}): {e}"));
560                        assert!(chain.expected_attempts(&p).is_finite(), "{id} '{input}'");
561                        // `15` on Bitcoin may fairly be read as lead `1` + `5`.
562                        if p.prefix.len() == fixed + k {
563                            assert!(
564                                chain.matches(a, &p),
565                                "{id} '{input}' → '{}' misses {a}",
566                                p.prefix
567                            );
568                        }
569                        // Typing the full start is never ambiguous.
570                        let full = &a[..fixed + k];
571                        if let Ok(p) = chain.build_pattern(Some(full), None, None, exact) {
572                            assert!(
573                                chain.matches(a, &p),
574                                "{id} '{full}' → '{}' misses {a}",
575                                p.prefix
576                            );
577                        }
578                    }
579                }
580            }
581        }
582    }
583
584    #[test]
585    fn deploy_modes_resolve_and_roundtrip() {
586        for (alias, id) in [
587            ("evm-contract", "evm-contract"),
588            ("contract", "evm-contract"),
589            ("sol-mint", "sol-mint"),
590            ("mint", "sol-mint"),
591        ] {
592            let chain = Chain::from_id(alias).unwrap_or_else(|e| panic!("{alias}: {e}"));
593            assert_eq!(chain.id(), id);
594            let (addr, attempt) = chain.grind_attempt();
595            assert_eq!(chain.finalize(attempt).address, addr);
596        }
597    }
598
599    /// Prefix / suffix / contains estimates must honor ignore-case only when both
600    /// letter cases exist in the alphabet (Base58 `i`/`o` stay full-cost).
601    #[test]
602    fn estimate_modes_respect_case_and_alphabet() {
603        // Solana: suffix + contains share the same char math.
604        let sol = Chain::from_id("sol").unwrap();
605        let suffix = sol
606            .build_pattern(None, Some("aiboss"), None, false)
607            .unwrap();
608        let contains = sol
609            .build_pattern(None, None, Some("aiboss"), false)
610            .unwrap();
611        let want = 29.0_f64.powi(4) * 58.0_f64.powi(2);
612        assert!(
613            (sol.expected_attempts(&suffix) - want).abs() < 1.0,
614            "sol suffix aiboss"
615        );
616        assert!(
617            (sol.expected_attempts(&contains) - want).abs() < 1.0,
618            "sol contains aiboss"
619        );
620        let exact = sol.build_pattern(None, Some("aiboss"), None, true).unwrap();
621        assert!((sol.expected_attempts(&exact) - 58.0_f64.powi(6)).abs() < 1.0);
622
623        // BTC-like layout: ignore-case suffix must not still use 58^n.
624        let btc = Chain::from_id("btc").unwrap();
625        let p = btc.build_pattern(None, Some("ab"), None, false).unwrap();
626        assert!((btc.expected_attempts(&p) - 29.0 * 29.0).abs() < 1e-6);
627        let p = btc.build_pattern(None, Some("ab"), None, true).unwrap();
628        assert!((btc.expected_attempts(&p) - 58.0 * 58.0).abs() < 1e-6);
629        // Single-case letter `o` stays 58 even when ignore-case.
630        let p = btc.build_pattern(None, Some("ao"), None, false).unwrap();
631        assert!((btc.expected_attempts(&p) - 29.0 * 58.0).abs() < 1e-6);
632
633        // Hex chains: always 16^n (case normalized).
634        let evm = Chain::from_id("evm").unwrap();
635        for (mode, build) in [
636            ("prefix", evm.build_pattern(Some("ab"), None, None, false)),
637            ("suffix", evm.build_pattern(None, Some("ab"), None, false)),
638            ("contains", evm.build_pattern(None, None, Some("ab"), false)),
639        ] {
640            let p = build.unwrap();
641            assert!(
642                (evm.expected_attempts(&p) - 16.0_f64.powi(2)).abs() < 1e-9,
643                "evm {mode}"
644            );
645        }
646
647        // Bech32: lowercase-only alphabet → always 32^n (exact case unsupported).
648        let seg = Chain::from_id("btc-segwit").unwrap();
649        let p = seg.build_pattern(None, Some("qp"), None, false).unwrap();
650        assert!((seg.expected_attempts(&p) - 32.0 * 32.0).abs() < 1e-6);
651
652        // TON base64url: letters have both cases → ignore-case halves letter cost.
653        let ton = Chain::from_id("ton").unwrap();
654        let ignore = ton.build_pattern(None, Some("ab"), None, false).unwrap();
655        let exact = ton.build_pattern(None, Some("ab"), None, true).unwrap();
656        assert!((ton.expected_attempts(&ignore) - 32.0 * 32.0).abs() < 1e-6);
657        assert!((ton.expected_attempts(&exact) - 64.0 * 64.0).abs() < 1e-6);
658
659        // Combined suffix+contains multiplies.
660        let both = sol
661            .build_pattern(None, Some("ab"), Some("cd"), false)
662            .unwrap();
663        assert!((sol.expected_attempts(&both) - 29.0_f64.powi(4)).abs() < 1e-6);
664    }
665}