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