hopr-api 1.6.0

Common high-level external and internal API traits used by hopr-lib to implement the HOPR protocol
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
122
123
124
125
126
127
128
129

mod accounts;
mod channels;
mod events;
mod keys;
mod safe;
mod tickets;
mod values;

pub use accounts::*;
pub use channels::*;
pub use events::*;
pub use keys::*;
pub use safe::*;
pub use tickets::*;
pub use values::*;

/// Receipt of an on-chain operation.
pub type ChainReceipt = hopr_types::crypto::prelude::Hash;

/// Complete set of HOPR on-chain operation APIs.
///
/// This trait is automatically implemented for types
/// that implement all the individual chain API traits with the same error.
pub trait HoprChainApi:
    ChainReadAccountOperations<Error = Self::ChainError>
    + ChainWriteAccountOperations<Error = Self::ChainError>
    + ChainReadChannelOperations<Error = Self::ChainError>
    + ChainWriteChannelOperations<Error = Self::ChainError>
    + ChainReadSafeOperations<Error = Self::ChainError>
    + ChainWriteSafeOperations<Error = Self::ChainError>
    + ChainEvents<Error = Self::ChainError>
    + ChainKeyOperations<Error = Self::ChainError>
    + ChainValues<Error = Self::ChainError>
    + ChainReadTicketOperations<Error = Self::ChainError>
    + ChainWriteTicketOperations<Error = Self::ChainError>
{
    type ChainError: std::error::Error + Send + Sync + 'static;
}

impl<T, E> HoprChainApi for T
where
    T: ChainReadAccountOperations<Error = E>
        + ChainWriteAccountOperations<Error = E>
        + ChainReadChannelOperations<Error = E>
        + ChainWriteChannelOperations<Error = E>
        + ChainReadSafeOperations<Error = E>
        + ChainWriteSafeOperations<Error = E>
        + ChainEvents<Error = E>
        + ChainKeyOperations<Error = E>
        + ChainValues<Error = E>
        + ChainReadTicketOperations<Error = E>
        + ChainWriteTicketOperations<Error = E>,
    E: std::error::Error + Send + Sync + 'static,
{
    type ChainError = E;
}

/// Reduced set of read-only HOPR on-chain operation APIs.
///
/// Useful when only basic on-chain operations are required for querying.
///
/// This trait is automatically implemented for types
/// that implement all the individual chain API traits with the same error.
pub trait HoprStaticChainApi:
    ChainReadSafeOperations<Error = Self::ChainError> + ChainValues<Error = Self::ChainError>
{
    type ChainError: std::error::Error + Send + Sync + 'static;
}

impl<T, E> HoprStaticChainApi for T
where
    T: ChainReadSafeOperations<Error = E> + ChainValues<Error = E>,
    E: std::error::Error + Send + Sync + 'static,
{
    type ChainError = E;
}

/// The `PathAddressResolver` which uses the [HOPR chain API](self) to resolve addresses and channels.
///
/// This type implements a `From` trait for all types that implement both
/// [`ChainKeyOperations`] and [`ChainReadChannelOperations`].
pub struct ChainPathResolver<'a, R>(&'a R);

impl<R> Clone for ChainPathResolver<'_, R> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<R> Copy for ChainPathResolver<'_, R> {}

impl<'a, R: ChainKeyOperations + ChainReadChannelOperations> From<&'a R> for ChainPathResolver<'a, R> {
    fn from(value: &'a R) -> Self {
        Self(value)
    }
}

#[async_trait::async_trait]
impl<'c, R: ChainKeyOperations + ChainReadChannelOperations + Sync> hopr_types::internal::path::PathAddressResolver
    for ChainPathResolver<'c, R>
{
    async fn resolve_transport_address(
        &self,
        address: &hopr_types::primitive::prelude::Address,
    ) -> Result<Option<hopr_types::crypto::prelude::OffchainPublicKey>, hopr_types::internal::errors::PathError> {
        self.0
            .chain_key_to_packet_key(address)
            .map_err(|e| hopr_types::internal::errors::PathError::UnknownPeer(format!("{address}: {e}")))
    }

    async fn resolve_chain_address(
        &self,
        key: &hopr_types::crypto::prelude::OffchainPublicKey,
    ) -> Result<Option<hopr_types::primitive::prelude::Address>, hopr_types::internal::errors::PathError> {
        self.0
            .packet_key_to_chain_key(key)
            .map_err(|e| hopr_types::internal::errors::PathError::UnknownPeer(format!("{key}: {e}")))
    }

    async fn get_channel(
        &self,
        src: &hopr_types::primitive::prelude::Address,
        dst: &hopr_types::primitive::prelude::Address,
    ) -> Result<Option<ChannelEntry>, hopr_types::internal::errors::PathError> {
        self.0.channel_by_parties(src, dst).map_err(|e| {
            hopr_types::internal::errors::PathError::MissingChannel(src.to_string(), format!("{dst}: {e}"))
        })
    }
}