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 puzzle;
20mod ripple;
21mod solana;
22mod split_key;
23mod stellar;
24mod sui;
25mod tezos;
26mod ton;
27mod tron;
28mod tron_contract;
29mod util;
30
31pub use algorand::AlgorandGrinder;
32pub use aptos::AptosGrinder;
33pub use bitcoin_like::BitcoinLikeGrinder;
34pub use bitcoin_segwit::BitcoinSegwitGrinder;
35pub use cardano::CardanoGrinder;
36pub use cosmos::CosmosGrinder;
37pub use create2::Create2Grinder;
38pub use evm::EvmGrinder;
39pub use evm_contract::EvmContractGrinder;
40pub use filecoin::FilecoinGrinder;
41pub use hedera::HederaGrinder;
42pub use icp::IcpGrinder;
43pub use kaspa::KaspaGrinder;
44pub use kusama::KusamaGrinder;
45pub use multiversx::MultiversXGrinder;
46pub use near::NearGrinder;
47pub use polkadot::PolkadotGrinder;
48pub use puzzle::PuzzleGrinder;
49pub use ripple::RippleGrinder;
50pub use solana::{SolanaGrinder, SolanaMintGrinder};
51pub use split_key::{
52 combine_split_keys, generate_split_keypair, parse_public_key, parse_secret_key,
53 SplitKeyGrinder, SplitKeypair,
54};
55pub use stellar::StellarGrinder;
56pub use sui::SuiGrinder;
57pub use tezos::TezosGrinder;
58pub use ton::TonGrinder;
59pub use tron::TronGrinder;
60pub use tron_contract::TronContractGrinder;
61
62use crate::chain::{ChainGrinder, GrindAttempt, KeypairResult};
63use crate::pattern::Pattern;
64
65#[derive(Clone)]
66pub enum Chain {
67 Solana(SolanaGrinder),
68 Evm(EvmGrinder),
69 Bitcoin(BitcoinLikeGrinder),
70 BitcoinSegwit(BitcoinSegwitGrinder),
71 BitcoinTaproot(BitcoinSegwitGrinder),
72 Litecoin(BitcoinLikeGrinder),
73 Dogecoin(BitcoinLikeGrinder),
74 Dash(BitcoinLikeGrinder),
75 BitcoinFamily(BitcoinLikeGrinder),
77 Puzzle(PuzzleGrinder),
79 SplitKey(SplitKeyGrinder),
81 Tron(TronGrinder),
82 Cosmos(CosmosGrinder),
83 Osmosis(CosmosGrinder),
84 Sei(CosmosGrinder),
85 Injective(CosmosGrinder),
86 Celestia(CosmosGrinder),
87 Dydx(CosmosGrinder),
88 Ripple(RippleGrinder),
89 Stellar(StellarGrinder),
90 Aptos(AptosGrinder),
91 Sui(SuiGrinder),
92 Near(NearGrinder),
93 Algorand(AlgorandGrinder),
94 Tezos(TezosGrinder),
95 Icp(IcpGrinder),
96 Kaspa(KaspaGrinder),
97 Kusama(KusamaGrinder),
98 Ton(TonGrinder),
99 Filecoin(FilecoinGrinder),
100 Polkadot(PolkadotGrinder),
101 Cardano(CardanoGrinder),
102 Hedera(HederaGrinder),
103 MultiversX(MultiversXGrinder),
104 Create2(Create2Grinder),
105 EvmContract(EvmContractGrinder),
106 TronContract(TronContractGrinder),
107 SolanaMint(SolanaMintGrinder),
108}
109
110pub const DEPLOY_MODES: [(&str, &str); 4] = [
113 ("evm-contract", "EVM contract (CREATE · nonce 0)"),
114 ("trx-contract", "Tron contract (CREATE · nonce 0)"),
115 ("sol-mint", "Solana token mint"),
116 (
117 "create2",
118 "EVM CREATE2 salt (needs deployer + init-code-hash)",
119 ),
120];
121
122pub const MENU_CHAINS: &[(&str, &str)] = &[
125 ("algo", "Algorand (base32)"),
126 ("aptos", "Aptos (0x hex)"),
127 ("btc", "Bitcoin (base58 · P2PKH)"),
128 ("btg", "Bitcoin Gold (base58 · P2PKH)"),
129 ("btc-segwit", "Bitcoin SegWit (bc1q · P2WPKH)"),
130 ("btc-taproot", "Bitcoin Taproot (bc1p)"),
131 ("cdn", "Canada eCoin (base58 · P2PKH)"),
132 ("ada", "Cardano (enterprise addr1)"),
133 ("tia", "Celestia (bech32 · TIA)"),
134 ("cosmos", "Cosmos (bech32 · ATOM)"),
135 ("dash", "Dash (base58 · P2PKH)"),
136 ("dgb", "DigiByte (base58 · P2PKH)"),
137 ("doge", "Dogecoin (base58)"),
138 ("dydx", "dYdX (bech32)"),
139 ("emc2", "Einsteinium (base58 · P2PKH)"),
140 ("evm", "EVM (0x hex · MetaMask / Base / Robinhood…)"),
141 ("fil", "Filecoin (f1 · secp256k1)"),
142 ("hedera", "Hedera (ed25519 pubkey hex)"),
143 ("inj", "Injective (bech32 · INJ)"),
144 ("icp", "Internet Computer (principal)"),
145 ("kaspa", "Kaspa (bech32)"),
146 ("ksm", "Kusama (SS58 · ed25519)"),
147 ("ltc", "Litecoin (base58 · P2PKH)"),
148 ("mona", "Monacoin (base58 · P2PKH)"),
149 ("erd", "MultiversX (bech32 · erd1)"),
150 ("near", "NEAR (hex implicit account)"),
151 ("nvc", "Novacoin (base58 · P2PKH)"),
152 ("osmo", "Osmosis (bech32 · OSMO)"),
153 ("ppc", "Peercoin (base58 · P2PKH)"),
154 ("dot", "Polkadot (SS58 · ed25519)"),
155 ("xpm", "Primecoin (base58 · P2PKH)"),
156 ("qtum", "Qtum (base58 · P2PKH)"),
157 ("rvn", "Ravencoin (base58 · P2PKH)"),
158 ("xrp", "Ripple (base58 · r…)"),
159 ("sei", "Sei (bech32 · SEI)"),
160 ("sol", "Solana (base58 · Phantom, Solflare)"),
161 ("xlm", "Stellar (strkey · G…)"),
162 ("sui", "Sui (0x hex)"),
163 ("sys", "Syscoin (base58 · P2PKH)"),
164 ("xtz", "Tezos (tz1 · ed25519)"),
165 ("ton", "TON (Wallet V4R2 · UQ…)"),
166 ("trx", "Tron (base58 · T…)"),
167 ("vtc", "Vertcoin (base58 · P2PKH)"),
168 ("via", "Viacoin (base58 · P2PKH)"),
169];
170
171impl Chain {
172 pub fn chars_per_position(&self, ignore_case: bool) -> f64 {
175 match self.id() {
176 "evm" | "evm-contract" | "create2" | "aptos" | "sui" | "near" | "hedera" => 16.0,
177 "ton" if ignore_case => 37.0,
178 "ton" => 64.0,
179 "sol" | "sol-mint" | "btc" | "ltc" | "doge" | "dash" | "trx" | "trx-contract"
180 | "xrp" | "dot" | "ksm" | "xtz" | "btg" | "rvn" | "mona" | "vtc" | "dgb" | "ppc"
181 | "qtum" | "via" | "xpm" | "emc2" | "sys" | "nvc" | "cdn" => {
182 if ignore_case {
184 29.0
185 } else {
186 58.0
187 }
188 }
189 _ => 32.0,
190 }
191 }
192
193 pub fn from_menu_index(index: usize) -> Option<Self> {
194 let (id, _) = MENU_CHAINS.get(index)?;
195 Self::from_id(id).ok()
196 }
197
198 pub fn from_id(id: &str) -> Result<Self, String> {
199 let id = id.to_ascii_lowercase();
200 match id.as_str() {
201 "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
202 "sol-mint" | "spl-mint" | "mint" => Ok(Chain::SolanaMint(SolanaMintGrinder)),
203 "evm" | "eth" | "ethereum" | "base" | "arb" | "arbitrum" | "op" | "optimism"
205 | "polygon" | "matic" | "avax" | "avalanche" | "bnb" | "bsc" | "fantom" | "ftm"
206 | "scroll" | "linea" | "zksync" | "blast" | "mantle" | "mode" | "bera"
207 | "berachain" | "monad" | "abstract" | "unichain" | "robinhood" | "hood" | "rh"
208 | "hyperliquid" | "hyperevm" | "hype" | "sonic" => Ok(Chain::Evm(EvmGrinder)),
209 "evm-contract" | "evm-create" | "contract" => {
210 Ok(Chain::EvmContract(EvmContractGrinder))
211 }
212 "trx-contract" | "tron-contract" => Ok(Chain::TronContract(TronContractGrinder)),
213 "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
214 "btc-segwit" | "segwit" | "bc1q" => {
215 Ok(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit()))
216 }
217 "btc-taproot" | "taproot" | "bc1p" => {
218 Ok(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot()))
219 }
220 "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
221 "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
222 "dash" => Ok(Chain::Dash(BitcoinLikeGrinder::dash())),
223 "btg" | "rvn" | "mona" | "vtc" | "dgb" | "ppc" | "qtum" | "via" | "xpm" | "emc2"
225 | "sys" | "nvc" | "cdn" => {
226 let g = BitcoinLikeGrinder::by_id(&id)
227 .ok_or_else(|| format!("Unknown Bitcoin-family id '{id}'"))?;
228 Ok(Chain::BitcoinFamily(g))
229 }
230 "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
231 "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
232 "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
233 "sei" => Ok(Chain::Sei(CosmosGrinder::sei())),
234 "inj" | "injective" => Ok(Chain::Injective(CosmosGrinder::injective())),
235 "tia" | "celestia" => Ok(Chain::Celestia(CosmosGrinder::celestia())),
236 "dydx" => Ok(Chain::Dydx(CosmosGrinder::dydx())),
237 "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
238 "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
239 "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
240 "sui" => Ok(Chain::Sui(SuiGrinder)),
241 "near" => Ok(Chain::Near(NearGrinder)),
242 "algo" | "algorand" => Ok(Chain::Algorand(AlgorandGrinder)),
243 "xtz" | "tezos" => Ok(Chain::Tezos(TezosGrinder)),
244 "icp" | "internet-computer" | "dfinity" => Ok(Chain::Icp(IcpGrinder)),
245 "kaspa" | "kas" => Ok(Chain::Kaspa(KaspaGrinder)),
246 "ksm" | "kusama" => Ok(Chain::Kusama(KusamaGrinder)),
247 "ton" => Ok(Chain::Ton(TonGrinder)),
248 "fil" | "filecoin" => Ok(Chain::Filecoin(FilecoinGrinder)),
249 "dot" | "polkadot" | "substrate" => Ok(Chain::Polkadot(PolkadotGrinder)),
250 "ada" | "cardano" => Ok(Chain::Cardano(CardanoGrinder)),
251 "hedera" | "hbar" => Ok(Chain::Hedera(HederaGrinder)),
252 "erd" | "mvx" | "elrond" | "multiversx" => Ok(Chain::MultiversX(MultiversXGrinder)),
253 "create2" => Err(
254 "CREATE2 needs a deployer and init-code-hash — use resolve_chain / --create2 --deployer --init-code-hash"
255 .into(),
256 ),
257 _ => Err(format!(
258 "Unknown chain '{id}'. Supported: {} (deploy modes: {})",
259 Self::supported_ids_display(),
260 DEPLOY_MODES
261 .iter()
262 .map(|(id, _)| *id)
263 .collect::<Vec<_>>()
264 .join(", ")
265 )),
266 }
267 }
268
269 pub fn resolve_chain(
271 id: &str,
272 deployer: Option<&str>,
273 init_code_hash: Option<&str>,
274 ) -> Result<Self, String> {
275 let id = id.trim().to_ascii_lowercase();
276 if id == "create2" {
277 let deployer = deployer
278 .filter(|s| !s.is_empty())
279 .ok_or("create2 requires deployer (20-byte hex)")?;
280 let init_code_hash = init_code_hash
281 .filter(|s| !s.is_empty())
282 .ok_or("create2 requires init-code-hash (32-byte hex)")?;
283 return Ok(Chain::Create2(Create2Grinder::parse(
284 deployer,
285 init_code_hash,
286 )?));
287 }
288 Self::from_id(&id)
289 }
290
291 pub fn all_ids() -> Vec<&'static str> {
293 MENU_CHAINS.iter().map(|(id, _)| *id).collect()
294 }
295
296 fn supported_ids_display() -> String {
297 MENU_CHAINS
298 .iter()
299 .map(|(id, _)| *id)
300 .collect::<Vec<_>>()
301 .join(", ")
302 }
303}
304
305macro_rules! dispatch {
306 ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
307 match $self {
308 Chain::Solana(g) => g.$method($($arg),*),
309 Chain::Evm(g) => g.$method($($arg),*),
310 Chain::Bitcoin(g) => g.$method($($arg),*),
311 Chain::BitcoinSegwit(g) => g.$method($($arg),*),
312 Chain::BitcoinTaproot(g) => g.$method($($arg),*),
313 Chain::Litecoin(g) => g.$method($($arg),*),
314 Chain::Dogecoin(g) => g.$method($($arg),*),
315 Chain::Dash(g) => g.$method($($arg),*),
316 Chain::BitcoinFamily(g) => g.$method($($arg),*),
317 Chain::Puzzle(g) => g.$method($($arg),*),
318 Chain::SplitKey(g) => g.$method($($arg),*),
319 Chain::Tron(g) => g.$method($($arg),*),
320 Chain::Cosmos(g) => g.$method($($arg),*),
321 Chain::Osmosis(g) => g.$method($($arg),*),
322 Chain::Sei(g) => g.$method($($arg),*),
323 Chain::Injective(g) => g.$method($($arg),*),
324 Chain::Celestia(g) => g.$method($($arg),*),
325 Chain::Dydx(g) => g.$method($($arg),*),
326 Chain::Ripple(g) => g.$method($($arg),*),
327 Chain::Stellar(g) => g.$method($($arg),*),
328 Chain::Aptos(g) => g.$method($($arg),*),
329 Chain::Sui(g) => g.$method($($arg),*),
330 Chain::Near(g) => g.$method($($arg),*),
331 Chain::Algorand(g) => g.$method($($arg),*),
332 Chain::Tezos(g) => g.$method($($arg),*),
333 Chain::Icp(g) => g.$method($($arg),*),
334 Chain::Kaspa(g) => g.$method($($arg),*),
335 Chain::Kusama(g) => g.$method($($arg),*),
336 Chain::Ton(g) => g.$method($($arg),*),
337 Chain::Filecoin(g) => g.$method($($arg),*),
338 Chain::Polkadot(g) => g.$method($($arg),*),
339 Chain::Cardano(g) => g.$method($($arg),*),
340 Chain::Hedera(g) => g.$method($($arg),*),
341 Chain::MultiversX(g) => g.$method($($arg),*),
342 Chain::Create2(g) => g.$method($($arg),*),
343 Chain::EvmContract(g) => g.$method($($arg),*),
344 Chain::TronContract(g) => g.$method($($arg),*),
345 Chain::SolanaMint(g) => g.$method($($arg),*),
346 }
347 };
348}
349
350impl ChainGrinder for Chain {
351 fn id(&self) -> &'static str {
352 dispatch!(self, id())
353 }
354
355 fn display_name(&self) -> &'static str {
356 dispatch!(self, display_name())
357 }
358
359 fn grind_attempt(&self) -> (String, GrindAttempt) {
360 dispatch!(self, grind_attempt())
361 }
362
363 fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
364 dispatch!(self, finalize(attempt))
365 }
366
367 fn build_pattern(
368 &self,
369 prefix: Option<&str>,
370 suffix: Option<&str>,
371 contains: Option<&str>,
372 exact: bool,
373 ) -> Result<Pattern, String> {
374 dispatch!(self, build_pattern(prefix, suffix, contains, exact))
375 }
376
377 fn expected_attempts(&self, pattern: &Pattern) -> f64 {
378 dispatch!(self, expected_attempts(pattern))
379 }
380
381 fn matches(&self, address: &str, pattern: &Pattern) -> bool {
382 dispatch!(self, matches(address, pattern))
383 }
384
385 fn supports_exact_case(&self) -> bool {
386 dispatch!(self, supports_exact_case())
387 }
388
389 fn pattern_hint(&self) -> &'static str {
390 dispatch!(self, pattern_hint())
391 }
392}
393
394#[cfg(test)]
395mod tests {
396 use super::Chain;
397 use crate::chain::ChainGrinder;
398
399 #[test]
400 fn all_menu_chains_resolve_and_grind() {
401 assert_eq!(super::MENU_CHAINS.len(), Chain::all_ids().len());
402 assert!(super::MENU_CHAINS.len() >= 31);
403 for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
404 let chain = Chain::from_menu_index(i).expect("menu index");
405 assert_eq!(chain.id(), *id);
406 let via_id = Chain::from_id(id).expect("from_id");
407 assert_eq!(via_id.id(), *id);
408 let (addr, attempt) = chain.grind_attempt();
409 assert!(!addr.is_empty(), "{id} empty address");
410 let finalized = chain.finalize(attempt);
411 assert_eq!(finalized.address, addr, "{id} finalize mismatch");
412 assert!(!finalized.exports.is_empty(), "{id} missing exports");
413 }
414 }
415
416 #[test]
417 fn from_menu_index_matches_menu_chains_order() {
418 for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
419 let chain = Chain::from_menu_index(i).expect("menu index");
420 assert_eq!(
421 chain.id(),
422 *id,
423 "from_menu_index({i}) misaligned with MENU_CHAINS"
424 );
425 }
426 assert!(Chain::from_menu_index(super::MENU_CHAINS.len()).is_none());
427 }
428
429 #[test]
430 fn menu_chains_sorted_a_to_z_by_label() {
431 let labels: Vec<&str> = super::MENU_CHAINS.iter().map(|(_, label)| *label).collect();
432 let mut sorted = labels.clone();
433 sorted.sort_by_key(|a| a.to_ascii_lowercase());
434 assert_eq!(labels, sorted, "MENU_CHAINS must stay A–Z by display name");
435 for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
436 assert_eq!(Chain::all_ids()[i], *id);
437 }
438 }
439
440 #[test]
441 fn evm_trending_aliases_resolve() {
442 for id in [
443 "robinhood",
444 "hood",
445 "base",
446 "arb",
447 "optimism",
448 "polygon",
449 "avax",
450 "bnb",
451 "monad",
452 "hyperliquid",
453 "hyperevm",
454 "sonic",
455 ] {
456 let c = Chain::from_id(id).unwrap_or_else(|e| panic!("{id}: {e}"));
457 assert_eq!(c.id(), "evm");
458 }
459 }
460
461 #[test]
462 fn chain_forced_prefix_is_not_counted_as_difficulty() {
463 for (id, input) in [
464 ("evm", "ab"),
465 ("evm-contract", "ab"),
466 ("trx-contract", "ab"),
467 ("kaspa", "pq"),
468 ("cosmos", "qp"),
469 ("sei", "qp"),
470 ("btc-segwit", "qp"),
471 ("btc-taproot", "qp"),
472 ("ada", "8x"),
473 ("erd", "qp"),
474 ("ton", "ab"),
475 ("xlm", "ab"),
476 ("xtz", "ab"),
477 ("fil", "ab"),
478 ("btc", "ab"),
479 ("ltc", "ab"),
480 ("doge", "ab"),
481 ("dash", "ph"),
482 ("trx", "ab"),
483 ("xrp", "ab"),
484 ("dot", "ab"),
485 ] {
486 let chain = Chain::from_id(id).unwrap();
487 let p = chain
488 .build_pattern(Some(input), None, None, false)
489 .unwrap_or_else(|e| panic!("{id} {input}: {e}"));
490 assert_eq!(
491 p.effective_literal_chars(),
492 2,
493 "{id} '{input}' → '{}'",
494 p.prefix
495 );
496 let est = crate::grind_estimate(chain.expected_attempts(&p), 500_000.0, &p);
497 assert_eq!(est.risk, crate::PatternRisk::None, "{id} '{input}'");
498 }
499 }
500
501 #[test]
502 fn impossible_address_starts_are_rejected() {
503 for (id, input) in [
504 ("kaspa", "ax"),
505 ("ada", "ax"),
506 ("ada", "va"),
507 ("ton", "zz"),
508 ("xlm", "XY"),
509 ("xlm", "GZ"),
510 ("doge", "z"),
511 ("ltc", "1"),
512 ("dash", "1"),
513 ("trx", "1"),
514 ("xtz", "1"),
515 ("ksm", "a"),
516 ] {
517 let chain = Chain::from_id(id).unwrap();
518 let err = chain
519 .build_pattern(Some(input), None, None, false)
520 .expect_err(&format!("{id} '{input}' should be rejected"));
521 assert!(err.contains("can never"), "{id} '{input}': {err}");
522 }
523 }
524
525 #[test]
526 fn constrained_start_lowers_expected_attempts() {
527 let chain = Chain::from_id("kaspa").unwrap();
528 let p = chain.build_pattern(Some("qp"), None, None, false).unwrap();
529 assert_eq!(p.prefix, "kaspa:qp");
530 assert!((chain.expected_attempts(&p) - 4.0).abs() < 1e-9);
532
533 let btc = Chain::from_id("btc").unwrap();
534 let p = btc.build_pattern(Some("1ab"), None, None, false).unwrap();
535 assert_eq!(p.prefix, "1ab");
536 assert_eq!(p.effective_literal_chars(), 2);
537
538 let doge = Chain::from_id("doge").unwrap();
540 let p = doge.build_pattern(Some("A"), None, None, true).unwrap();
541 let tries = doge.expected_attempts(&p);
542 assert!((20.0..30.0).contains(&tries), "doge 'A' → {tries}");
543 }
544
545 #[test]
546 fn ambiguous_lead_picks_the_reading_that_exists() {
547 for (id, input, want) in [
549 ("doge", "D1", "DD1"),
550 ("trx", "T1", "TT1"),
551 ("ltc", "L1", "LL1"),
552 ("kaspa", "q0", "kaspa:qq0"),
553 ("kaspa", "qp", "kaspa:qp"),
554 ("ada", "8", "addr1v8"),
555 ("btc", "1ab", "1ab"),
556 ] {
557 let chain = Chain::from_id(id).unwrap();
558 let p = chain.build_pattern(Some(input), None, None, true).unwrap();
559 assert_eq!(p.prefix, want, "{id} '{input}'");
560 }
561 }
562
563 #[test]
566 fn real_address_starts_are_always_accepted() {
567 let mut ids: Vec<&str> = Chain::all_ids().to_vec();
568 ids.extend(["evm-contract", "trx-contract", "sol-mint"]);
569 for id in ids {
570 let chain = Chain::from_id(id).unwrap();
571 let addrs: Vec<String> = (0..300).map(|_| chain.grind_attempt().0).collect();
572 let fixed = (0..addrs[0].len())
573 .take_while(|&i| {
574 addrs
575 .iter()
576 .all(|a| a.as_bytes()[i] == addrs[0].as_bytes()[i])
577 })
578 .count();
579 for a in &addrs {
580 for k in 1..=3 {
581 let input = &a[fixed..fixed + k];
582 for exact in [true, false] {
583 let p = chain
584 .build_pattern(Some(input), None, None, exact)
585 .unwrap_or_else(|e| panic!("{id} '{input}' (from {a}): {e}"));
586 assert!(chain.expected_attempts(&p).is_finite(), "{id} '{input}'");
587 if p.prefix.len() == fixed + k {
589 assert!(
590 chain.matches(a, &p),
591 "{id} '{input}' → '{}' misses {a}",
592 p.prefix
593 );
594 }
595 let full = &a[..fixed + k];
597 if let Ok(p) = chain.build_pattern(Some(full), None, None, exact) {
598 assert!(
599 chain.matches(a, &p),
600 "{id} '{full}' → '{}' misses {a}",
601 p.prefix
602 );
603 }
604 }
605 }
606 }
607 }
608 }
609
610 #[test]
611 fn deploy_modes_resolve_and_roundtrip() {
612 for (alias, id) in [
613 ("evm-contract", "evm-contract"),
614 ("contract", "evm-contract"),
615 ("trx-contract", "trx-contract"),
616 ("tron-contract", "trx-contract"),
617 ("sol-mint", "sol-mint"),
618 ("mint", "sol-mint"),
619 ] {
620 let chain = Chain::from_id(alias).unwrap_or_else(|e| panic!("{alias}: {e}"));
621 assert_eq!(chain.id(), id);
622 let (addr, attempt) = chain.grind_attempt();
623 assert_eq!(chain.finalize(attempt).address, addr);
624 }
625 assert!(Chain::from_id("create2").is_err());
626 let c2 = Chain::resolve_chain(
627 "create2",
628 Some("0x0000000000000000000000000000000000000001"),
629 Some("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"),
630 )
631 .unwrap();
632 assert_eq!(c2.id(), "create2");
633 }
634
635 #[test]
638 fn estimate_modes_respect_case_and_alphabet() {
639 let sol = Chain::from_id("sol").unwrap();
641 let suffix = sol
642 .build_pattern(None, Some("aiboss"), None, false)
643 .unwrap();
644 let contains = sol
645 .build_pattern(None, None, Some("aiboss"), false)
646 .unwrap();
647 let want = 29.0_f64.powi(4) * 58.0_f64.powi(2);
648 assert!(
649 (sol.expected_attempts(&suffix) - want).abs() < 1.0,
650 "sol suffix aiboss"
651 );
652 assert!(
653 (sol.expected_attempts(&contains) - want).abs() < 1.0,
654 "sol contains aiboss"
655 );
656 let exact = sol.build_pattern(None, Some("aiboss"), None, true).unwrap();
657 assert!((sol.expected_attempts(&exact) - 58.0_f64.powi(6)).abs() < 1.0);
658
659 let btc = Chain::from_id("btc").unwrap();
661 let p = btc.build_pattern(None, Some("ab"), None, false).unwrap();
662 assert!((btc.expected_attempts(&p) - 29.0 * 29.0).abs() < 1e-6);
663 let p = btc.build_pattern(None, Some("ab"), None, true).unwrap();
664 assert!((btc.expected_attempts(&p) - 58.0 * 58.0).abs() < 1e-6);
665 let p = btc.build_pattern(None, Some("ao"), None, false).unwrap();
667 assert!((btc.expected_attempts(&p) - 29.0 * 58.0).abs() < 1e-6);
668
669 let evm = Chain::from_id("evm").unwrap();
671 for (mode, build) in [
672 ("prefix", evm.build_pattern(Some("ab"), None, None, false)),
673 ("suffix", evm.build_pattern(None, Some("ab"), None, false)),
674 ("contains", evm.build_pattern(None, None, Some("ab"), false)),
675 ] {
676 let p = build.unwrap();
677 assert!(
678 (evm.expected_attempts(&p) - 16.0_f64.powi(2)).abs() < 1e-9,
679 "evm {mode}"
680 );
681 }
682
683 let seg = Chain::from_id("btc-segwit").unwrap();
685 let p = seg.build_pattern(None, Some("qp"), None, false).unwrap();
686 assert!((seg.expected_attempts(&p) - 32.0 * 32.0).abs() < 1e-6);
687
688 let ton = Chain::from_id("ton").unwrap();
690 let ignore = ton.build_pattern(None, Some("ab"), None, false).unwrap();
691 let exact = ton.build_pattern(None, Some("ab"), None, true).unwrap();
692 assert!((ton.expected_attempts(&ignore) - 32.0 * 32.0).abs() < 1e-6);
693 assert!((ton.expected_attempts(&exact) - 64.0 * 64.0).abs() < 1e-6);
694
695 let both = sol
697 .build_pattern(None, Some("ab"), Some("cd"), false)
698 .unwrap();
699 assert!((sol.expected_attempts(&both) - 29.0_f64.powi(4)).abs() < 1e-6);
700 }
701}