ibc-relayer 0.32.2

Implementation of an IBC Relayer in Rust, as a library 
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

use std::time::Duration;

use tracing::{error_span, trace, warn};

use crate::{
    chain::handle::ChainHandle,
    telemetry,
    util::task::{spawn_background_task, Next, TaskError, TaskHandle},
};

pub fn spawn_wallet_worker<Chain: ChainHandle>(chain: Chain) -> TaskHandle {
    let span = error_span!("wallet", chain = %chain.id());

    spawn_background_task(span, Some(Duration::from_secs(5)), move || {
        let chain_config = chain
            .config()
            .map_err(|e| TaskError::Fatal(format!("failed to get chain config: {e}").into()))?;

        if !chain_config.keyring_support() {
            return Err(TaskError::Ignore(
                format!("chain {} does not support keyring", chain.id()).into(),
            ));
        }

        let key = chain.get_key().map_err(|e| {
            TaskError::Fatal(Box::new(format!(
                "failed to get key in use by the relayer: {e}"
            )))
        })?;

        let balance = chain.query_balance(None, None).map_err(|e| {
            TaskError::Ignore(Box::new(format!(
                "failed to query balance for the account: {e}"
            )))
        })?;

        match balance.amount.parse::<f64>() {
            Ok(amount) => {
                telemetry!(
                    wallet_balance,
                    &chain.id(),
                    &key.account(),
                    amount,
                    &balance.denom,
                );
                trace!(%amount, denom = %balance.denom, account = %key.account(), "wallet balance");
                telemetry!(
                    update_period_fees,
                    &chain.id(),
                    &key.account(),
                    &balance.denom
                );
            }
            Err(e) => {
                warn!(
                    %balance.amount, denom = %balance.denom, account = %key.account(),
                    "unable to parse the wallet balance into a f64, the balance will therefore not be reported to telemetry. Reason: {}", e
                );
            }
        }
        Ok(Next::Continue)
    })
}

#[cfg(test)]
mod tests {
    use ibc_relayer_types::bigint::U256;

    // Test to confirm that any u256 fits in f64
    #[test]
    fn compare_f64_max_to_u256_max() {
        let f64_max = f64::MAX;
        let u256_max = U256::MAX;

        assert!(f64_max > u256_max.to_string().parse::<f64>().unwrap());
    }
}