ethers-abirpc 0.3.0

ethers-rs provider encapsulation for ethereum smart contrcats
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

use {
    crate::{error::Error, named::NamedChain},
    std::{clone::Clone, cmp},
    strum_macros::Display,
};

#[derive(Debug, PartialEq, Copy, Clone)]
pub struct RetryClientConfig {
    pub rate_limit_retries: u32,
    pub timeout_retries: u32,
    pub initial_backoff_ms: u64,
}

impl Default for RetryClientConfig {
    fn default() -> Self {
        Self {
            rate_limit_retries: 10,
            timeout_retries: 3,
            initial_backoff_ms: 500,
        }
    }
}

#[derive(Debug, PartialEq, Copy, Clone, Default)]
pub struct ChainConfig {
    pub chain_id: u64,
    pub retry_client_config: RetryClientConfig,
    pub assert_chain_id: bool,
}

#[derive(Debug, PartialEq, Copy, Clone, Display)]
pub enum Chain {
    Id(u64),
    ChainConfig(ChainConfig),
}

impl From<u64> for Chain {
    fn from(id: u64) -> Self {
        Self::Id(id)
    }
}

impl From<NamedChain> for Chain {
    fn from(named: NamedChain) -> Self {
        Self::Id(named as u64)
    }
}

impl Chain {
    pub fn id(&self) -> u64 {
        match self {
            Chain::Id(chain_id) => *chain_id,
            Chain::ChainConfig(config) => config.chain_id,
        }
    }

    pub fn from_id(id: u64) -> Self {
        Chain::from(id)
    }

    pub fn named(&self) -> Option<NamedChain> {
        match self {
            Chain::Id(chain_id) => NamedChain::try_from(*chain_id)
                .map_err(Error::NamedChainError)
                .ok(),
            Chain::ChainConfig(config) => NamedChain::try_from(config.chain_id)
                .map_err(Error::NamedChainError)
                .ok(),
        }
    }

    pub fn from_named(named: NamedChain) -> Self {
        Chain::from(named)
    }

    pub fn retry_client_config(&self) -> RetryClientConfig {
        match self {
            Chain::Id(chain_id) => match NamedChain::try_from(*chain_id) {
                Ok(named) => {
                    let default = RetryClientConfig::default().initial_backoff_ms;

                    let initial_backoff_ms = match named.average_blocktime_hint() {
                        Some(duration) => {
                            let interval = (duration.as_millis() as u64) / 10;
                            cmp::max(100, cmp::min(default, interval))
                        }
                        None => default,
                    };
                    RetryClientConfig {
                        initial_backoff_ms,
                        ..RetryClientConfig::default()
                    }
                }
                Err(_) => RetryClientConfig::default(),
            },
            Chain::ChainConfig(config) => config.retry_client_config,
        }
    }

    pub fn assert_chain_id(&self) -> bool {
        match self {
            Chain::Id(_) => true,
            Chain::ChainConfig(config) => config.assert_chain_id,
        }
    }
}