Skip to main content

vanity_core/chains/
mod.rs

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