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