1mod algorand;
2mod aptos;
3mod bitcoin_like;
4mod bitcoin_segwit;
5mod cardano;
6mod cosmos;
7pub mod create2;
8mod evm;
9mod evm_contract;
10mod filecoin;
11mod hedera;
12mod icp;
13mod kaspa;
14mod kusama;
15mod multiversx;
16mod near;
17mod polkadot;
18mod ripple;
19mod solana;
20mod stellar;
21mod sui;
22mod tezos;
23mod ton;
24mod tron;
25mod util;
26
27pub use algorand::AlgorandGrinder;
28pub use aptos::AptosGrinder;
29pub use bitcoin_like::BitcoinLikeGrinder;
30pub use bitcoin_segwit::BitcoinSegwitGrinder;
31pub use cardano::CardanoGrinder;
32pub use cosmos::CosmosGrinder;
33pub use create2::Create2Grinder;
34pub use evm::EvmGrinder;
35pub use evm_contract::EvmContractGrinder;
36pub use filecoin::FilecoinGrinder;
37pub use hedera::HederaGrinder;
38pub use icp::IcpGrinder;
39pub use kaspa::KaspaGrinder;
40pub use kusama::KusamaGrinder;
41pub use multiversx::MultiversXGrinder;
42pub use near::NearGrinder;
43pub use polkadot::PolkadotGrinder;
44pub use ripple::RippleGrinder;
45pub use solana::{SolanaGrinder, SolanaMintGrinder};
46pub use stellar::StellarGrinder;
47pub use sui::SuiGrinder;
48pub use tezos::TezosGrinder;
49pub use ton::TonGrinder;
50pub use tron::TronGrinder;
51
52use crate::chain::{ChainGrinder, GrindAttempt, KeypairResult};
53use crate::pattern::Pattern;
54
55#[derive(Clone)]
56pub enum Chain {
57 Solana(SolanaGrinder),
58 Evm(EvmGrinder),
59 Bitcoin(BitcoinLikeGrinder),
60 BitcoinSegwit(BitcoinSegwitGrinder),
61 BitcoinTaproot(BitcoinSegwitGrinder),
62 Litecoin(BitcoinLikeGrinder),
63 Dogecoin(BitcoinLikeGrinder),
64 Dash(BitcoinLikeGrinder),
65 Tron(TronGrinder),
66 Cosmos(CosmosGrinder),
67 Osmosis(CosmosGrinder),
68 Sei(CosmosGrinder),
69 Injective(CosmosGrinder),
70 Celestia(CosmosGrinder),
71 Dydx(CosmosGrinder),
72 Ripple(RippleGrinder),
73 Stellar(StellarGrinder),
74 Aptos(AptosGrinder),
75 Sui(SuiGrinder),
76 Near(NearGrinder),
77 Algorand(AlgorandGrinder),
78 Tezos(TezosGrinder),
79 Icp(IcpGrinder),
80 Kaspa(KaspaGrinder),
81 Kusama(KusamaGrinder),
82 Ton(TonGrinder),
83 Filecoin(FilecoinGrinder),
84 Polkadot(PolkadotGrinder),
85 Cardano(CardanoGrinder),
86 Hedera(HederaGrinder),
87 MultiversX(MultiversXGrinder),
88 Create2(Create2Grinder),
89 EvmContract(EvmContractGrinder),
90 SolanaMint(SolanaMintGrinder),
91}
92
93pub const MENU_CHAINS: [(&str, &str); 31] = [
96 ("algo", "Algorand (base32)"),
97 ("aptos", "Aptos (0x hex)"),
98 ("btc", "Bitcoin (base58 · P2PKH)"),
99 ("btc-segwit", "Bitcoin SegWit (bc1q · P2WPKH)"),
100 ("btc-taproot", "Bitcoin Taproot (bc1p)"),
101 ("ada", "Cardano (enterprise addr1)"),
102 ("tia", "Celestia (bech32 · TIA)"),
103 ("cosmos", "Cosmos (bech32 · ATOM)"),
104 ("dash", "Dash (base58 · P2PKH)"),
105 ("doge", "Dogecoin (base58)"),
106 ("dydx", "dYdX (bech32)"),
107 ("evm", "EVM (0x hex · MetaMask / Base / Robinhood…)"),
108 ("fil", "Filecoin (f1 · secp256k1)"),
109 ("hedera", "Hedera (ed25519 pubkey hex)"),
110 ("inj", "Injective (bech32 · INJ)"),
111 ("icp", "Internet Computer (principal)"),
112 ("kaspa", "Kaspa (bech32)"),
113 ("ksm", "Kusama (SS58 · ed25519)"),
114 ("ltc", "Litecoin (base58 · P2PKH)"),
115 ("erd", "MultiversX (bech32 · erd1)"),
116 ("near", "NEAR (hex implicit account)"),
117 ("osmo", "Osmosis (bech32 · OSMO)"),
118 ("dot", "Polkadot (SS58 · ed25519)"),
119 ("xrp", "Ripple (base58 · r…)"),
120 ("sei", "Sei (bech32 · SEI)"),
121 ("sol", "Solana (base58 · Phantom, Solflare)"),
122 ("xlm", "Stellar (strkey · G…)"),
123 ("sui", "Sui (0x hex)"),
124 ("xtz", "Tezos (tz1 · ed25519)"),
125 ("ton", "TON (Wallet V4R2 · UQ…)"),
126 ("trx", "Tron (base58 · T…)"),
127];
128
129impl Chain {
130 pub fn from_menu_index(index: usize) -> Option<Self> {
131 match index {
132 0 => Some(Chain::Algorand(AlgorandGrinder)),
133 1 => Some(Chain::Aptos(AptosGrinder)),
134 2 => Some(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
135 3 => Some(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit())),
136 4 => Some(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot())),
137 5 => Some(Chain::Cardano(CardanoGrinder)),
138 6 => Some(Chain::Celestia(CosmosGrinder::celestia())),
139 7 => Some(Chain::Cosmos(CosmosGrinder::cosmos())),
140 8 => Some(Chain::Dash(BitcoinLikeGrinder::dash())),
141 9 => Some(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
142 10 => Some(Chain::Dydx(CosmosGrinder::dydx())),
143 11 => Some(Chain::Evm(EvmGrinder)),
144 12 => Some(Chain::Filecoin(FilecoinGrinder)),
145 13 => Some(Chain::Hedera(HederaGrinder)),
146 14 => Some(Chain::Injective(CosmosGrinder::injective())),
147 15 => Some(Chain::Icp(IcpGrinder)),
148 16 => Some(Chain::Kaspa(KaspaGrinder)),
149 17 => Some(Chain::Kusama(KusamaGrinder)),
150 18 => Some(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
151 19 => Some(Chain::MultiversX(MultiversXGrinder)),
152 20 => Some(Chain::Near(NearGrinder)),
153 21 => Some(Chain::Osmosis(CosmosGrinder::osmosis())),
154 22 => Some(Chain::Polkadot(PolkadotGrinder)),
155 23 => Some(Chain::Ripple(RippleGrinder)),
156 24 => Some(Chain::Sei(CosmosGrinder::sei())),
157 25 => Some(Chain::Solana(SolanaGrinder)),
158 26 => Some(Chain::Stellar(StellarGrinder)),
159 27 => Some(Chain::Sui(SuiGrinder)),
160 28 => Some(Chain::Tezos(TezosGrinder)),
161 29 => Some(Chain::Ton(TonGrinder)),
162 30 => Some(Chain::Tron(TronGrinder)),
163 _ => None,
164 }
165 }
166
167 pub fn from_id(id: &str) -> Result<Self, String> {
168 let id = id.to_ascii_lowercase();
169 match id.as_str() {
170 "sol" | "solana" => Ok(Chain::Solana(SolanaGrinder)),
171 "sol-mint" | "spl-mint" | "mint" => Ok(Chain::SolanaMint(SolanaMintGrinder)),
172 "evm" | "eth" | "ethereum" | "base" | "arb" | "arbitrum" | "op" | "optimism"
174 | "polygon" | "matic" | "avax" | "avalanche" | "bnb" | "bsc" | "fantom" | "ftm"
175 | "scroll" | "linea" | "zksync" | "blast" | "mantle" | "mode" | "bera"
176 | "berachain" | "monad" | "abstract" | "unichain" | "robinhood" | "hood" | "rh"
177 | "hyperliquid" | "hyperevm" | "hype" | "sonic" => Ok(Chain::Evm(EvmGrinder)),
178 "evm-contract" | "evm-create" | "contract" => {
179 Ok(Chain::EvmContract(EvmContractGrinder))
180 }
181 "btc" | "bitcoin" => Ok(Chain::Bitcoin(BitcoinLikeGrinder::bitcoin())),
182 "btc-segwit" | "segwit" | "bc1q" => {
183 Ok(Chain::BitcoinSegwit(BitcoinSegwitGrinder::segwit()))
184 }
185 "btc-taproot" | "taproot" | "bc1p" => {
186 Ok(Chain::BitcoinTaproot(BitcoinSegwitGrinder::taproot()))
187 }
188 "ltc" | "litecoin" => Ok(Chain::Litecoin(BitcoinLikeGrinder::litecoin())),
189 "doge" | "dogecoin" => Ok(Chain::Dogecoin(BitcoinLikeGrinder::dogecoin())),
190 "dash" => Ok(Chain::Dash(BitcoinLikeGrinder::dash())),
191 "trx" | "tron" => Ok(Chain::Tron(TronGrinder)),
192 "cosmos" | "atom" => Ok(Chain::Cosmos(CosmosGrinder::cosmos())),
193 "osmo" | "osmosis" => Ok(Chain::Osmosis(CosmosGrinder::osmosis())),
194 "sei" => Ok(Chain::Sei(CosmosGrinder::sei())),
195 "inj" | "injective" => Ok(Chain::Injective(CosmosGrinder::injective())),
196 "tia" | "celestia" => Ok(Chain::Celestia(CosmosGrinder::celestia())),
197 "dydx" => Ok(Chain::Dydx(CosmosGrinder::dydx())),
198 "xrp" | "ripple" => Ok(Chain::Ripple(RippleGrinder)),
199 "xlm" | "stellar" => Ok(Chain::Stellar(StellarGrinder)),
200 "aptos" | "apt" => Ok(Chain::Aptos(AptosGrinder)),
201 "sui" => Ok(Chain::Sui(SuiGrinder)),
202 "near" => Ok(Chain::Near(NearGrinder)),
203 "algo" | "algorand" => Ok(Chain::Algorand(AlgorandGrinder)),
204 "xtz" | "tezos" => Ok(Chain::Tezos(TezosGrinder)),
205 "icp" | "internet-computer" | "dfinity" => Ok(Chain::Icp(IcpGrinder)),
206 "kaspa" | "kas" => Ok(Chain::Kaspa(KaspaGrinder)),
207 "ksm" | "kusama" => Ok(Chain::Kusama(KusamaGrinder)),
208 "ton" => Ok(Chain::Ton(TonGrinder)),
209 "fil" | "filecoin" => Ok(Chain::Filecoin(FilecoinGrinder)),
210 "dot" | "polkadot" | "substrate" => Ok(Chain::Polkadot(PolkadotGrinder)),
211 "ada" | "cardano" => Ok(Chain::Cardano(CardanoGrinder)),
212 "hedera" | "hbar" => Ok(Chain::Hedera(HederaGrinder)),
213 "erd" | "mvx" | "elrond" | "multiversx" => Ok(Chain::MultiversX(MultiversXGrinder)),
214 _ => Err(format!(
215 "Unknown chain '{id}'. Supported: {} (deploy modes: evm-contract, sol-mint)",
216 Self::supported_ids_display()
217 )),
218 }
219 }
220
221 pub fn all_ids() -> &'static [&'static str] {
223 &[
224 "algo",
225 "aptos",
226 "btc",
227 "btc-segwit",
228 "btc-taproot",
229 "ada",
230 "tia",
231 "cosmos",
232 "dash",
233 "doge",
234 "dydx",
235 "evm",
236 "fil",
237 "hedera",
238 "inj",
239 "icp",
240 "kaspa",
241 "ksm",
242 "ltc",
243 "erd",
244 "near",
245 "osmo",
246 "dot",
247 "xrp",
248 "sei",
249 "sol",
250 "xlm",
251 "sui",
252 "xtz",
253 "ton",
254 "trx",
255 ]
256 }
257
258 fn supported_ids_display() -> String {
259 Self::all_ids().join(", ")
260 }
261}
262
263macro_rules! dispatch {
264 ($self:expr, $method:ident ( $($arg:expr),* $(,)? )) => {
265 match $self {
266 Chain::Solana(g) => g.$method($($arg),*),
267 Chain::Evm(g) => g.$method($($arg),*),
268 Chain::Bitcoin(g) => g.$method($($arg),*),
269 Chain::BitcoinSegwit(g) => g.$method($($arg),*),
270 Chain::BitcoinTaproot(g) => g.$method($($arg),*),
271 Chain::Litecoin(g) => g.$method($($arg),*),
272 Chain::Dogecoin(g) => g.$method($($arg),*),
273 Chain::Dash(g) => g.$method($($arg),*),
274 Chain::Tron(g) => g.$method($($arg),*),
275 Chain::Cosmos(g) => g.$method($($arg),*),
276 Chain::Osmosis(g) => g.$method($($arg),*),
277 Chain::Sei(g) => g.$method($($arg),*),
278 Chain::Injective(g) => g.$method($($arg),*),
279 Chain::Celestia(g) => g.$method($($arg),*),
280 Chain::Dydx(g) => g.$method($($arg),*),
281 Chain::Ripple(g) => g.$method($($arg),*),
282 Chain::Stellar(g) => g.$method($($arg),*),
283 Chain::Aptos(g) => g.$method($($arg),*),
284 Chain::Sui(g) => g.$method($($arg),*),
285 Chain::Near(g) => g.$method($($arg),*),
286 Chain::Algorand(g) => g.$method($($arg),*),
287 Chain::Tezos(g) => g.$method($($arg),*),
288 Chain::Icp(g) => g.$method($($arg),*),
289 Chain::Kaspa(g) => g.$method($($arg),*),
290 Chain::Kusama(g) => g.$method($($arg),*),
291 Chain::Ton(g) => g.$method($($arg),*),
292 Chain::Filecoin(g) => g.$method($($arg),*),
293 Chain::Polkadot(g) => g.$method($($arg),*),
294 Chain::Cardano(g) => g.$method($($arg),*),
295 Chain::Hedera(g) => g.$method($($arg),*),
296 Chain::MultiversX(g) => g.$method($($arg),*),
297 Chain::Create2(g) => g.$method($($arg),*),
298 Chain::EvmContract(g) => g.$method($($arg),*),
299 Chain::SolanaMint(g) => g.$method($($arg),*),
300 }
301 };
302}
303
304impl ChainGrinder for Chain {
305 fn id(&self) -> &'static str {
306 dispatch!(self, id())
307 }
308
309 fn display_name(&self) -> &'static str {
310 dispatch!(self, display_name())
311 }
312
313 fn grind_attempt(&self) -> (String, GrindAttempt) {
314 dispatch!(self, grind_attempt())
315 }
316
317 fn finalize(&self, attempt: GrindAttempt) -> KeypairResult {
318 dispatch!(self, finalize(attempt))
319 }
320
321 fn build_pattern(
322 &self,
323 prefix: Option<&str>,
324 suffix: Option<&str>,
325 contains: Option<&str>,
326 exact: bool,
327 ) -> Result<Pattern, String> {
328 dispatch!(self, build_pattern(prefix, suffix, contains, exact))
329 }
330
331 fn expected_attempts(&self, pattern: &Pattern) -> f64 {
332 dispatch!(self, expected_attempts(pattern))
333 }
334
335 fn matches(&self, address: &str, pattern: &Pattern) -> bool {
336 dispatch!(self, matches(address, pattern))
337 }
338
339 fn supports_exact_case(&self) -> bool {
340 dispatch!(self, supports_exact_case())
341 }
342
343 fn pattern_hint(&self) -> &'static str {
344 dispatch!(self, pattern_hint())
345 }
346}
347
348#[cfg(test)]
349mod tests {
350 use super::Chain;
351 use crate::chain::ChainGrinder;
352
353 #[test]
354 fn all_menu_chains_resolve_and_grind() {
355 assert_eq!(super::MENU_CHAINS.len(), 31);
356 assert_eq!(Chain::all_ids().len(), 31);
357 for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
358 let chain = Chain::from_menu_index(i).expect("menu index");
359 assert_eq!(chain.id(), *id);
360 let via_id = Chain::from_id(id).expect("from_id");
361 assert_eq!(via_id.id(), *id);
362 let (addr, attempt) = chain.grind_attempt();
363 assert!(!addr.is_empty(), "{id} empty address");
364 let finalized = chain.finalize(attempt);
365 assert_eq!(finalized.address, addr, "{id} finalize mismatch");
366 assert!(!finalized.exports.is_empty(), "{id} missing exports");
367 }
368 }
369
370 #[test]
371 fn from_menu_index_matches_menu_chains_order() {
372 for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
373 let chain = Chain::from_menu_index(i).expect("menu index");
374 assert_eq!(
375 chain.id(),
376 *id,
377 "from_menu_index({i}) misaligned with MENU_CHAINS"
378 );
379 }
380 assert!(Chain::from_menu_index(super::MENU_CHAINS.len()).is_none());
381 }
382
383 #[test]
384 fn menu_chains_sorted_a_to_z_by_label() {
385 let labels: Vec<&str> = super::MENU_CHAINS.iter().map(|(_, label)| *label).collect();
386 let mut sorted = labels.clone();
387 sorted.sort_by_key(|a| a.to_ascii_lowercase());
388 assert_eq!(labels, sorted, "MENU_CHAINS must stay A–Z by display name");
389 for (i, (id, _)) in super::MENU_CHAINS.iter().enumerate() {
390 assert_eq!(Chain::all_ids()[i], *id);
391 }
392 }
393
394 #[test]
395 fn evm_trending_aliases_resolve() {
396 for id in [
397 "robinhood",
398 "hood",
399 "base",
400 "arb",
401 "optimism",
402 "polygon",
403 "avax",
404 "bnb",
405 "monad",
406 "hyperliquid",
407 "hyperevm",
408 "sonic",
409 ] {
410 let c = Chain::from_id(id).unwrap_or_else(|e| panic!("{id}: {e}"));
411 assert_eq!(c.id(), "evm");
412 }
413 }
414
415 #[test]
416 fn deploy_modes_resolve_and_roundtrip() {
417 for (alias, id) in [
418 ("evm-contract", "evm-contract"),
419 ("contract", "evm-contract"),
420 ("sol-mint", "sol-mint"),
421 ("mint", "sol-mint"),
422 ] {
423 let chain = Chain::from_id(alias).unwrap_or_else(|e| panic!("{alias}: {e}"));
424 assert_eq!(chain.id(), id);
425 let (addr, attempt) = chain.grind_attempt();
426 assert_eq!(chain.finalize(attempt).address, addr);
427 }
428 }
429}