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