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