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                if ignore_case {
141                    34.0
142                } else {
143                    58.0
144                }
145            }
146            _ => 32.0,
147        }
148    }
149
150    pub fn from_menu_index(index: usize) -> Option<Self> {
151        match index {
152            0 => Some(Chain::Algorand(AlgorandGrinder)),
153            1 => Some(Chain::Aptos(AptosGrinder)),
154            2 => Some(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
155            3 => Some(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit())),
156            4 => Some(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot())),
157            5 => Some(Chain::Cardano(CardanoGrinder)),
158            6 => Some(Chain::Celestia(CosmosGrinder::celestia())),
159            7 => Some(Chain::Cosmos(CosmosGrinder::cosmos())),
160            8 => Some(Chain::Dash(BitcoinLikeGrinder::dash())),
161            9 => Some(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
162            10 => Some(Chain::Dydx(CosmosGrinder::dydx())),
163            11 => Some(Chain::Evm(EvmGrinder)),
164            12 => Some(Chain::Filecoin(FilecoinGrinder)),
165            13 => Some(Chain::Hedera(HederaGrinder)),
166            14 => Some(Chain::Injective(CosmosGrinder::injective())),
167            15 => Some(Chain::Icp(IcpGrinder)),
168            16 => Some(Chain::Kaspa(KaspaGrinder)),
169            17 => Some(Chain::Kusama(KusamaGrinder)),
170            18 => Some(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
171            19 => Some(Chain::MultiversX(MultiversXGrinder)),
172            20 => Some(Chain::Near(NearGrinder)),
173            21 => Some(Chain::Osmosis(CosmosGrinder::osmosis())),
174            22 => Some(Chain::Polkadot(PolkadotGrinder)),
175            23 => Some(Chain::Ripple(RippleGrinder)),
176            24 => Some(Chain::Sei(CosmosGrinder::sei())),
177            25 => Some(Chain::Solana(SolanaGrinder)),
178            26 => Some(Chain::Stellar(StellarGrinder)),
179            27 => Some(Chain::Sui(SuiGrinder)),
180            28 => Some(Chain::Tezos(TezosGrinder)),
181            29 => Some(Chain::Ton(TonGrinder)),
182            30 => Some(Chain::Tron(TronGrinder)),
183            _ => None,
184        }
185    }
186
187    pub fn from_id(id: &str) -> Result<Self, String> {
188        let id = id.to_ascii_lowercase();
189        match id.as_str() {
190            "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
191            "sol-mint" | "spl-mint" | "mint" => Ok(Chain::SolanaMint(SolanaMintGrinder)),
192            // EVM + trending L2 / app-chain aliases (same address math)
193            "evm" | "eth" | "ethereum" | "base" | "arb" | "arbitrum" | "op" | "optimism"
194            | "polygon" | "matic" | "avax" | "avalanche" | "bnb" | "bsc" | "fantom" | "ftm"
195            | "scroll" | "linea" | "zksync" | "blast" | "mantle" | "mode" | "bera"
196            | "berachain" | "monad" | "abstract" | "unichain" | "robinhood" | "hood" | "rh"
197            | "hyperliquid" | "hyperevm" | "hype" | "sonic" => Ok(Chain::Evm(EvmGrinder)),
198            "evm-contract" | "evm-create" | "contract" => {
199                Ok(Chain::EvmContract(EvmContractGrinder))
200            }
201            "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
202            "btc-segwit" | "segwit" | "bc1q" => {
203                Ok(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit()))
204            }
205            "btc-taproot" | "taproot" | "bc1p" => {
206                Ok(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot()))
207            }
208            "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
209            "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
210            "dash" => Ok(Chain::Dash(BitcoinLikeGrinder::dash())),
211            "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
212            "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
213            "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
214            "sei" => Ok(Chain::Sei(CosmosGrinder::sei())),
215            "inj" | "injective" => Ok(Chain::Injective(CosmosGrinder::injective())),
216            "tia" | "celestia" => Ok(Chain::Celestia(CosmosGrinder::celestia())),
217            "dydx" => Ok(Chain::Dydx(CosmosGrinder::dydx())),
218            "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
219            "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
220            "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
221            "sui" => Ok(Chain::Sui(SuiGrinder)),
222            "near" => Ok(Chain::Near(NearGrinder)),
223            "algo" | "algorand" => Ok(Chain::Algorand(AlgorandGrinder)),
224            "xtz" | "tezos" => Ok(Chain::Tezos(TezosGrinder)),
225            "icp" | "internet-computer" | "dfinity" => Ok(Chain::Icp(IcpGrinder)),
226            "kaspa" | "kas" => Ok(Chain::Kaspa(KaspaGrinder)),
227            "ksm" | "kusama" => Ok(Chain::Kusama(KusamaGrinder)),
228            "ton" => Ok(Chain::Ton(TonGrinder)),
229            "fil" | "filecoin" => Ok(Chain::Filecoin(FilecoinGrinder)),
230            "dot" | "polkadot" | "substrate" => Ok(Chain::Polkadot(PolkadotGrinder)),
231            "ada" | "cardano" => Ok(Chain::Cardano(CardanoGrinder)),
232            "hedera" | "hbar" => Ok(Chain::Hedera(HederaGrinder)),
233            "erd" | "mvx" | "elrond" | "multiversx" => Ok(Chain::MultiversX(MultiversXGrinder)),
234            _ => Err(format!(
235                "Unknown chain '{id}'. Supported: {} (deploy modes: evm-contract, sol-mint)",
236                Self::supported_ids_display()
237            )),
238        }
239    }
240
241    /// Chain IDs in the same A–Z menu order.
242    pub fn all_ids() -> &'static [&'static str] {
243        &[
244            "algo",
245            "aptos",
246            "btc",
247            "btc-segwit",
248            "btc-taproot",
249            "ada",
250            "tia",
251            "cosmos",
252            "dash",
253            "doge",
254            "dydx",
255            "evm",
256            "fil",
257            "hedera",
258            "inj",
259            "icp",
260            "kaspa",
261            "ksm",
262            "ltc",
263            "erd",
264            "near",
265            "osmo",
266            "dot",
267            "xrp",
268            "sei",
269            "sol",
270            "xlm",
271            "sui",
272            "xtz",
273            "ton",
274            "trx",
275        ]
276    }
277
278    fn supported_ids_display() -> String {
279        Self::all_ids().join(", ")
280    }
281}
282
283macro_rules! dispatch {
284    ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
285        match $self {
286            Chain::Solana(g) => g.$method($($arg),*),
287            Chain::Evm(g) => g.$method($($arg),*),
288            Chain::Bitcoin(g) => g.$method($($arg),*),
289            Chain::BitcoinSegwit(g) => g.$method($($arg),*),
290            Chain::BitcoinTaproot(g) => g.$method($($arg),*),
291            Chain::Litecoin(g) => g.$method($($arg),*),
292            Chain::Dogecoin(g) => g.$method($($arg),*),
293            Chain::Dash(g) => g.$method($($arg),*),
294            Chain::Tron(g) => g.$method($($arg),*),
295            Chain::Cosmos(g) => g.$method($($arg),*),
296            Chain::Osmosis(g) => g.$method($($arg),*),
297            Chain::Sei(g) => g.$method($($arg),*),
298            Chain::Injective(g) => g.$method($($arg),*),
299            Chain::Celestia(g) => g.$method($($arg),*),
300            Chain::Dydx(g) => g.$method($($arg),*),
301            Chain::Ripple(g) => g.$method($($arg),*),
302            Chain::Stellar(g) => g.$method($($arg),*),
303            Chain::Aptos(g) => g.$method($($arg),*),
304            Chain::Sui(g) => g.$method($($arg),*),
305            Chain::Near(g) => g.$method($($arg),*),
306            Chain::Algorand(g) => g.$method($($arg),*),
307            Chain::Tezos(g) => g.$method($($arg),*),
308            Chain::Icp(g) => g.$method($($arg),*),
309            Chain::Kaspa(g) => g.$method($($arg),*),
310            Chain::Kusama(g) => g.$method($($arg),*),
311            Chain::Ton(g) => g.$method($($arg),*),
312            Chain::Filecoin(g) => g.$method($($arg),*),
313            Chain::Polkadot(g) => g.$method($($arg),*),
314            Chain::Cardano(g) => g.$method($($arg),*),
315            Chain::Hedera(g) => g.$method($($arg),*),
316            Chain::MultiversX(g) => g.$method($($arg),*),
317            Chain::Create2(g) => g.$method($($arg),*),
318            Chain::EvmContract(g) => g.$method($($arg),*),
319            Chain::SolanaMint(g) => g.$method($($arg),*),
320        }
321    };
322}
323
324impl ChainGrinder for Chain {
325    fn id(&self) -> &'static str {
326        dispatch!(self, id())
327    }
328
329    fn display_name(&self) -> &'static str {
330        dispatch!(self, display_name())
331    }
332
333    fn grind_attempt(&self) -> (String, GrindAttempt) {
334        dispatch!(self, grind_attempt())
335    }
336
337    fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
338        dispatch!(self, finalize(attempt))
339    }
340
341    fn build_pattern(
342        &self,
343        prefix: Option<&str>,
344        suffix: Option<&str>,
345        contains: Option<&str>,
346        exact: bool,
347    ) -> Result<Pattern, String> {
348        dispatch!(self, build_pattern(prefix, suffix, contains, exact))
349    }
350
351    fn expected_attempts(&self, pattern: &Pattern) -> f64 {
352        dispatch!(self, expected_attempts(pattern))
353    }
354
355    fn matches(&self, address: &str, pattern: &Pattern) -> bool {
356        dispatch!(self, matches(address, pattern))
357    }
358
359    fn supports_exact_case(&self) -> bool {
360        dispatch!(self, supports_exact_case())
361    }
362
363    fn pattern_hint(&self) -> &'static str {
364        dispatch!(self, pattern_hint())
365    }
366}
367
368#[cfg(test)]
369mod tests {
370    use super::Chain;
371    use crate::chain::ChainGrinder;
372
373    #[test]
374    fn all_menu_chains_resolve_and_grind() {
375        assert_eq!(super::MENU_CHAINS.len(), 31);
376        assert_eq!(Chain::all_ids().len(), 31);
377        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
378            let chain = Chain::from_menu_index(i).expect("menu index");
379            assert_eq!(chain.id(), *id);
380            let via_id = Chain::from_id(id).expect("from_id");
381            assert_eq!(via_id.id(), *id);
382            let (addr, attempt) = chain.grind_attempt();
383            assert!(!addr.is_empty(), "{id} empty address");
384            let finalized = chain.finalize(attempt);
385            assert_eq!(finalized.address, addr, "{id} finalize mismatch");
386            assert!(!finalized.exports.is_empty(), "{id} missing exports");
387        }
388    }
389
390    #[test]
391    fn from_menu_index_matches_menu_chains_order() {
392        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
393            let chain = Chain::from_menu_index(i).expect("menu index");
394            assert_eq!(
395                chain.id(),
396                *id,
397                "from_menu_index({i}) misaligned with MENU_CHAINS"
398            );
399        }
400        assert!(Chain::from_menu_index(super::MENU_CHAINS.len()).is_none());
401    }
402
403    #[test]
404    fn menu_chains_sorted_a_to_z_by_label() {
405        let labels: Vec<&str> = super::MENU_CHAINS.iter().map(|(_, label)| *label).collect();
406        let mut sorted = labels.clone();
407        sorted.sort_by_key(|a| a.to_ascii_lowercase());
408        assert_eq!(labels, sorted, "MENU_CHAINS must stay A–Z by display name");
409        for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
410            assert_eq!(Chain::all_ids()[i], *id);
411        }
412    }
413
414    #[test]
415    fn evm_trending_aliases_resolve() {
416        for id in [
417            "robinhood",
418            "hood",
419            "base",
420            "arb",
421            "optimism",
422            "polygon",
423            "avax",
424            "bnb",
425            "monad",
426            "hyperliquid",
427            "hyperevm",
428            "sonic",
429        ] {
430            let c = Chain::from_id(id).unwrap_or_else(|e| panic!("{id}: {e}"));
431            assert_eq!(c.id(), "evm");
432        }
433    }
434
435    #[test]
436    fn chain_forced_prefix_is_not_counted_as_difficulty() {
437        for (id, input) in [
438            ("evm", "ab"),
439            ("evm-contract", "ab"),
440            ("kaspa", "pq"),
441            ("cosmos", "qp"),
442            ("sei", "qp"),
443            ("btc-segwit", "qp"),
444            ("btc-taproot", "qp"),
445            ("ada", "8x"),
446            ("erd", "qp"),
447            ("ton", "ab"),
448            ("xlm", "ab"),
449            ("xtz", "ab"),
450            ("fil", "ab"),
451            ("btc", "ab"),
452            ("ltc", "ab"),
453            ("doge", "ab"),
454            ("dash", "ph"),
455            ("trx", "ab"),
456            ("xrp", "ab"),
457            ("dot", "ab"),
458        ] {
459            let chain = Chain::from_id(id).unwrap();
460            let p = chain
461                .build_pattern(Some(input), None, None, false)
462                .unwrap_or_else(|e| panic!("{id} {input}: {e}"));
463            assert_eq!(
464                p.effective_literal_chars(),
465                2,
466                "{id} '{input}' → '{}'",
467                p.prefix
468            );
469            let est = crate::grind_estimate(chain.expected_attempts(&p), 500_000.0, &p);
470            assert_eq!(est.risk, crate::PatternRisk::None, "{id} '{input}'");
471        }
472    }
473
474    #[test]
475    fn impossible_address_starts_are_rejected() {
476        for (id, input) in [
477            ("kaspa", "ax"),
478            ("ada", "ax"),
479            ("ada", "va"),
480            ("ton", "zz"),
481            ("xlm", "XY"),
482            ("xlm", "GZ"),
483            ("doge", "z"),
484            ("ltc", "1"),
485            ("dash", "1"),
486            ("trx", "1"),
487            ("xtz", "1"),
488            ("ksm", "a"),
489        ] {
490            let chain = Chain::from_id(id).unwrap();
491            let err = chain
492                .build_pattern(Some(input), None, None, false)
493                .expect_err(&format!("{id} '{input}' should be rejected"));
494            assert!(err.contains("can never"), "{id} '{input}': {err}");
495        }
496    }
497
498    #[test]
499    fn constrained_start_lowers_expected_attempts() {
500        let chain = Chain::from_id("kaspa").unwrap();
501        let p = chain.build_pattern(Some("qp"), None, None, false).unwrap();
502        assert_eq!(p.prefix, "kaspa:qp");
503        // `q` is certain, `p` is 1 of 4 → about 4 tries, not 32².
504        assert!((chain.expected_attempts(&p) - 4.0).abs() < 1e-9);
505
506        let btc = Chain::from_id("btc").unwrap();
507        let p = btc.build_pattern(Some("1ab"), None, None, false).unwrap();
508        assert_eq!(p.prefix, "1ab");
509        assert_eq!(p.effective_literal_chars(), 2);
510
511        // Doge is `D` + one of 24 characters, so `Da` takes ~24 tries, not 58.
512        let doge = Chain::from_id("doge").unwrap();
513        let p = doge.build_pattern(Some("A"), None, None, true).unwrap();
514        let tries = doge.expected_attempts(&p);
515        assert!((20.0..30.0).contains(&tries), "doge 'A' → {tries}");
516    }
517
518    #[test]
519    fn ambiguous_lead_picks_the_reading_that_exists() {
520        // `D1` can't follow the `D` lead, so it must mean `DD1…`.
521        for (id, input, want) in [
522            ("doge", "D1", "DD1"),
523            ("trx", "T1", "TT1"),
524            ("ltc", "L1", "LL1"),
525            ("kaspa", "q0", "kaspa:qq0"),
526            ("kaspa", "qp", "kaspa:qp"),
527            ("ada", "8", "addr1v8"),
528            ("btc", "1ab", "1ab"),
529        ] {
530            let chain = Chain::from_id(id).unwrap();
531            let p = chain.build_pattern(Some(input), None, None, true).unwrap();
532            assert_eq!(p.prefix, want, "{id} '{input}'");
533        }
534    }
535
536    /// Every real address must be reachable: the start of a freshly generated
537    /// address is never rejected and the resulting pattern matches it.
538    #[test]
539    fn real_address_starts_are_always_accepted() {
540        let mut ids: Vec<&str> = Chain::all_ids().to_vec();
541        ids.extend(["evm-contract", "sol-mint"]);
542        for id in ids {
543            let chain = Chain::from_id(id).unwrap();
544            let addrs: Vec<String> = (0..300).map(|_| chain.grind_attempt().0).collect();
545            let fixed = (0..addrs[0].len())
546                .take_while(|&i| {
547                    addrs
548                        .iter()
549                        .all(|a| a.as_bytes()[i] == addrs[0].as_bytes()[i])
550                })
551                .count();
552            for a in &addrs {
553                for k in 1..=3 {
554                    let input = &a[fixed..fixed + k];
555                    for exact in [true, false] {
556                        let p = chain
557                            .build_pattern(Some(input), None, None, exact)
558                            .unwrap_or_else(|e| panic!("{id} '{input}' (from {a}): {e}"));
559                        assert!(chain.expected_attempts(&p).is_finite(), "{id} '{input}'");
560                        // `15` on Bitcoin may fairly be read as lead `1` + `5`.
561                        if p.prefix.len() == fixed + k {
562                            assert!(
563                                chain.matches(a, &p),
564                                "{id} '{input}' → '{}' misses {a}",
565                                p.prefix
566                            );
567                        }
568                        // Typing the full start is never ambiguous.
569                        let full = &a[..fixed + k];
570                        if let Ok(p) = chain.build_pattern(Some(full), None, None, exact) {
571                            assert!(
572                                chain.matches(a, &p),
573                                "{id} '{full}' → '{}' misses {a}",
574                                p.prefix
575                            );
576                        }
577                    }
578                }
579            }
580        }
581    }
582
583    #[test]
584    fn deploy_modes_resolve_and_roundtrip() {
585        for (alias, id) in [
586            ("evm-contract", "evm-contract"),
587            ("contract", "evm-contract"),
588            ("sol-mint", "sol-mint"),
589            ("mint", "sol-mint"),
590        ] {
591            let chain = Chain::from_id(alias).unwrap_or_else(|e| panic!("{alias}: {e}"));
592            assert_eq!(chain.id(), id);
593            let (addr, attempt) = chain.grind_attempt();
594            assert_eq!(chain.finalize(attempt).address, addr);
595        }
596    }
597}