hopr_transport_protocol/msg/
packet.rs

1use hopr_db_api::protocol::TransportPacketWithChainData;
2use hopr_transport_identity::PeerId;
3
4use hopr_crypto_types::prelude::*;
5use hopr_internal_types::protocol::Acknowledgement;
6
7use crate::errors::ProtocolError;
8
9pub enum IncomingPacket {
10    /// Packet is intended for us
11    Final {
12        packet_tag: PacketTag,
13        previous_hop: PeerId,
14        plain_text: Box<[u8]>,
15        ack: Acknowledgement,
16    },
17    /// Packet must be forwarded
18    Forwarded {
19        packet_tag: PacketTag,
20        previous_hop: PeerId,
21        next_hop: PeerId,
22        data: Box<[u8]>,
23        ack: Acknowledgement,
24    },
25}
26
27impl TryFrom<TransportPacketWithChainData> for IncomingPacket {
28    type Error = ProtocolError;
29
30    fn try_from(value: TransportPacketWithChainData) -> std::result::Result<Self, ProtocolError> {
31        match value {
32            TransportPacketWithChainData::Final {
33                packet_tag,
34                previous_hop,
35                plain_text,
36                ack,
37            } => Ok(IncomingPacket::Final {
38                packet_tag,
39                previous_hop: previous_hop.into(),
40                plain_text,
41                ack,
42            }),
43            TransportPacketWithChainData::Forwarded {
44                packet_tag,
45                previous_hop,
46                next_hop,
47                data,
48                ack,
49            } => Ok(IncomingPacket::Forwarded {
50                packet_tag,
51                previous_hop: previous_hop.into(),
52                next_hop: next_hop.into(),
53                data,
54                ack,
55            }),
56            TransportPacketWithChainData::Outgoing { .. } => Err(ProtocolError::Logic(
57                "Outgoing packet received when processing incoming packets".to_string(),
58            )),
59        }
60    }
61}
62
63/// Packet that is being sent out by us
64pub struct OutgoingPacket {
65    pub next_hop: PeerId,
66    pub ack_challenge: HalfKeyChallenge,
67    pub data: Box<[u8]>,
68}
69
70impl TryFrom<TransportPacketWithChainData> for OutgoingPacket {
71    type Error = ProtocolError;
72
73    fn try_from(value: TransportPacketWithChainData) -> std::result::Result<Self, Self::Error> {
74        match value {
75            TransportPacketWithChainData::Final { .. } | TransportPacketWithChainData::Forwarded { .. } => Err(
76                ProtocolError::Logic("Incoming packet received when processing outgoing packets".to_string()),
77            ),
78            TransportPacketWithChainData::Outgoing {
79                next_hop,
80                ack_challenge,
81                data,
82            } => Ok(OutgoingPacket {
83                next_hop: next_hop.into(),
84                ack_challenge,
85                data,
86            }),
87        }
88    }
89}
90
91pub enum TransportPacket {
92    /// Packet is intended for us
93    Final {
94        packet_tag: PacketTag,
95        previous_hop: PeerId,
96        plain_text: Box<[u8]>,
97        ack: Acknowledgement,
98    },
99    /// Packet must be forwarded
100    Forwarded {
101        packet_tag: PacketTag,
102        previous_hop: PeerId,
103        next_hop: PeerId,
104        data: Box<[u8]>,
105        ack: Acknowledgement,
106    },
107    /// Packet that is being sent out by us
108    Outgoing {
109        next_hop: PeerId,
110        ack_challenge: HalfKeyChallenge,
111        data: Box<[u8]>,
112    },
113}
114
115impl From<IncomingPacket> for TransportPacket {
116    fn from(value: IncomingPacket) -> Self {
117        match value {
118            IncomingPacket::Final {
119                packet_tag,
120                previous_hop,
121                plain_text,
122                ack,
123            } => TransportPacket::Final {
124                packet_tag,
125                previous_hop,
126                plain_text,
127                ack,
128            },
129            IncomingPacket::Forwarded {
130                packet_tag,
131                previous_hop,
132                next_hop,
133                data,
134                ack,
135            } => TransportPacket::Forwarded {
136                packet_tag,
137                previous_hop,
138                next_hop,
139                data,
140                ack,
141            },
142        }
143    }
144}
145
146impl From<OutgoingPacket> for TransportPacket {
147    fn from(value: OutgoingPacket) -> Self {
148        TransportPacket::Outgoing {
149            next_hop: value.next_hop,
150            ack_challenge: value.ack_challenge,
151            data: value.data,
152        }
153    }
154}
hopr_transport_protocol/msg/packet.rs

hopr_transport_protocol/msg/
packet.rs
