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
94pub 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 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" | "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 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 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 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 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 #[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 if p.prefix.len() == fixed + k {
562 assert!(
563 chain.matches(a, &p),
564 "{id} '{input}' → '{}' misses {a}",
565 p.prefix
566 );
567 }
568 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}