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
97pub 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
109pub 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 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 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" | "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 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 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 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 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 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 #[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 if p.prefix.len() == fixed + k {
612 assert!(
613 chain.matches(a, &p),
614 "{id} '{input}' → '{}' misses {a}",
615 p.prefix
616 );
617 }
618 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 #[test]
661 fn estimate_modes_respect_case_and_alphabet() {
662 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 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 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 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 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 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 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}