evmify 0.1.1

EVM-ify any chain: a generic JSON-RPC client for EVM chains, plus a modular adapter -> normalizer -> transformer pipeline that serves non-EVM chains (Solana, Bitcoin, ...) as EVM blocks, transactions, receipts and logs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

//! Chain metadata.

/// What protocol family a chain speaks natively.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum ChainKind {
    Evm,
    Solana,
    Bitcoin,
    /// Anything else you add an adapter for.
    Other(&'static str),
}

/// Static description of a chain.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ChainInfo {
    /// Stable key, e.g. `"ethereum"`, `"solana-mainnet"`.
    pub key: String,
    pub name: String,
    pub kind: ChainKind,
    /// EIP-155 chain id. `None` for non-EVM chains unless you assign one.
    pub evm_chain_id: Option<u64>,
    pub native_symbol: String,
    /// Decimals of the native coin's base unit (18 for ETH, 9 for SOL, 8 for BTC).
    pub native_decimals: u8,
}

impl ChainInfo {
    pub fn new(key: &str, name: &str, kind: ChainKind, symbol: &str, decimals: u8) -> Self {
        Self {
            key: key.into(),
            name: name.into(),
            kind,
            evm_chain_id: None,
            native_symbol: symbol.into(),
            native_decimals: decimals,
        }
    }

    pub fn with_evm_chain_id(mut self, id: u64) -> Self {
        self.evm_chain_id = Some(id);
        self
    }

    /// A generic EVM chain known only by id (used when [`by_id`] has no entry).
    pub fn evm_unknown(chain_id: u64) -> Self {
        Self::new(
            &format!("evm-{chain_id}"),
            &format!("EVM chain {chain_id}"),
            ChainKind::Evm,
            "ETH",
            18,
        )
        .with_evm_chain_id(chain_id)
    }

    pub fn solana_mainnet() -> Self {
        Self::new("solana-mainnet", "Solana", ChainKind::Solana, "SOL", 9)
    }

    pub fn solana_devnet() -> Self {
        Self::new(
            "solana-devnet",
            "Solana Devnet",
            ChainKind::Solana,
            "SOL",
            9,
        )
    }

    pub fn bitcoin_mainnet() -> Self {
        Self::new("bitcoin", "Bitcoin", ChainKind::Bitcoin, "BTC", 8)
    }

    pub fn bitcoin_testnet() -> Self {
        Self::new(
            "bitcoin-testnet",
            "Bitcoin Testnet",
            ChainKind::Bitcoin,
            "tBTC",
            8,
        )
    }
}

/// `(chain id, key, name, native symbol)` for well-known EVM networks.
pub const KNOWN_EVM_CHAINS: &[(u64, &str, &str, &str)] = &[
    (1, "ethereum", "Ethereum", "ETH"),
    (10, "optimism", "OP Mainnet", "ETH"),
    (56, "bsc", "BNB Smart Chain", "BNB"),
    (100, "gnosis", "Gnosis", "xDAI"),
    (137, "polygon", "Polygon PoS", "POL"),
    (324, "zksync", "zkSync Era", "ETH"),
    (5000, "mantle", "Mantle", "MNT"),
    (8453, "base", "Base", "ETH"),
    (42161, "arbitrum", "Arbitrum One", "ETH"),
    (42220, "celo", "Celo", "CELO"),
    (43114, "avalanche", "Avalanche C-Chain", "AVAX"),
    (59144, "linea", "Linea", "ETH"),
    (81457, "blast", "Blast", "ETH"),
    (534352, "scroll", "Scroll", "ETH"),
    (11155111, "sepolia", "Sepolia", "ETH"),
    (84532, "base-sepolia", "Base Sepolia", "ETH"),
];

/// Look up a well-known EVM chain by EIP-155 id.
pub fn by_id(chain_id: u64) -> Option<ChainInfo> {
    KNOWN_EVM_CHAINS
        .iter()
        .find(|(id, ..)| *id == chain_id)
        .map(|(id, key, name, sym)| {
            ChainInfo::new(key, name, ChainKind::Evm, sym, 18).with_evm_chain_id(*id)
        })
}

/// Look up a well-known EVM chain by key (`"base"`, `"arbitrum"`, ...).
pub fn by_key(key: &str) -> Option<ChainInfo> {
    KNOWN_EVM_CHAINS
        .iter()
        .find(|(_, k, ..)| *k == key)
        .and_then(|(id, ..)| by_id(*id))
}