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