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

use serde::Serialize;

use super::{Ed25519KeyPair, KeyType, NamadaKeyPair, Secp256k1KeyPair, SigningKeyPair};

#[derive(Clone, Debug, Serialize)]
#[serde(untagged)]
pub enum AnySigningKeyPair {
    Secp256k1(Secp256k1KeyPair),
    Ed25519(Ed25519KeyPair),
    Namada(NamadaKeyPair),
}

impl AnySigningKeyPair {
    pub fn account(&self) -> String {
        match self {
            Self::Secp256k1(key_pair) => key_pair.account(),
            Self::Ed25519(key_pair) => key_pair.account(),
            Self::Namada(key_pair) => key_pair.account(),
        }
    }

    pub fn key_type(&self) -> KeyType {
        match self {
            Self::Secp256k1(_) => Secp256k1KeyPair::KEY_TYPE,
            Self::Ed25519(_) => Ed25519KeyPair::KEY_TYPE,
            Self::Namada(_) => NamadaKeyPair::KEY_TYPE,
        }
    }

    pub fn downcast<T: Clone + 'static>(&self) -> Option<T> {
        match self {
            Self::Secp256k1(key_pair) => key_pair.as_any(),
            Self::Ed25519(key_pair) => key_pair.as_any(),
            Self::Namada(key_pair) => key_pair.as_any(),
        }
        .downcast_ref::<T>()
        .cloned()
    }
}

impl From<Secp256k1KeyPair> for AnySigningKeyPair {
    fn from(key_pair: Secp256k1KeyPair) -> Self {
        Self::Secp256k1(key_pair)
    }
}

impl From<Ed25519KeyPair> for AnySigningKeyPair {
    fn from(key_pair: Ed25519KeyPair) -> Self {
        Self::Ed25519(key_pair)
    }
}

impl From<NamadaKeyPair> for AnySigningKeyPair {
    fn from(key_pair: NamadaKeyPair) -> Self {
        Self::Namada(key_pair)
    }
}