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