aldrin_core/message/
claim_channel_end_reply.rs

1use super::message_ops::Sealed;
2use super::{Message, MessageKind, MessageOps};
3use crate::message_deserializer::{MessageDeserializeError, MessageWithoutValueDeserializer};
4use crate::message_serializer::{MessageSerializeError, MessageSerializer};
5use crate::serialized_value::SerializedValueSlice;
6use bytes::BytesMut;
7use num_enum::{IntoPrimitive, TryFromPrimitive};
8
9#[derive(Debug, Copy, Clone, PartialEq, Eq, IntoPrimitive, TryFromPrimitive)]
10#[repr(u8)]
11enum ClaimChannelEndReplyKind {
12    SenderClaimed = 0,
13    ReceiverClaimed = 1,
14    InvalidChannel = 2,
15    AlreadyClaimed = 3,
16}
17
18#[derive(Debug, Copy, Clone, PartialEq, Eq)]
19#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
20pub enum ClaimChannelEndResult {
21    SenderClaimed(u32),
22    ReceiverClaimed,
23    InvalidChannel,
24    AlreadyClaimed,
25}
26
27#[derive(Debug, Copy, Clone, PartialEq, Eq)]
28#[cfg_attr(feature = "fuzzing", derive(arbitrary::Arbitrary))]
29pub struct ClaimChannelEndReply {
30    pub serial: u32,
31    pub result: ClaimChannelEndResult,
32}
33
34impl MessageOps for ClaimChannelEndReply {
35    fn kind(&self) -> MessageKind {
36        MessageKind::ClaimChannelEndReply
37    }
38
39    fn serialize_message(self) -> Result<BytesMut, MessageSerializeError> {
40        let mut serializer = MessageSerializer::without_value(MessageKind::ClaimChannelEndReply);
41
42        serializer.put_varint_u32_le(self.serial);
43
44        match self.result {
45            ClaimChannelEndResult::SenderClaimed(capacity) => {
46                serializer.put_discriminant_u8(ClaimChannelEndReplyKind::SenderClaimed);
47                serializer.put_varint_u32_le(capacity);
48            }
49            ClaimChannelEndResult::ReceiverClaimed => {
50                serializer.put_discriminant_u8(ClaimChannelEndReplyKind::ReceiverClaimed)
51            }
52            ClaimChannelEndResult::InvalidChannel => {
53                serializer.put_discriminant_u8(ClaimChannelEndReplyKind::InvalidChannel)
54            }
55            ClaimChannelEndResult::AlreadyClaimed => {
56                serializer.put_discriminant_u8(ClaimChannelEndReplyKind::AlreadyClaimed)
57            }
58        }
59
60        serializer.finish()
61    }
62
63    fn deserialize_message(buf: BytesMut) -> Result<Self, MessageDeserializeError> {
64        let mut deserializer =
65            MessageWithoutValueDeserializer::new(buf, MessageKind::ClaimChannelEndReply)?;
66
67        let serial = deserializer.try_get_varint_u32_le()?;
68
69        let result = match deserializer.try_get_discriminant_u8()? {
70            ClaimChannelEndReplyKind::SenderClaimed => {
71                let capacity = deserializer.try_get_varint_u32_le()?;
72                ClaimChannelEndResult::SenderClaimed(capacity)
73            }
74            ClaimChannelEndReplyKind::ReceiverClaimed => ClaimChannelEndResult::ReceiverClaimed,
75            ClaimChannelEndReplyKind::InvalidChannel => ClaimChannelEndResult::InvalidChannel,
76            ClaimChannelEndReplyKind::AlreadyClaimed => ClaimChannelEndResult::AlreadyClaimed,
77        };
78
79        deserializer.finish()?;
80        Ok(Self { serial, result })
81    }
82
83    fn value(&self) -> Option<&SerializedValueSlice> {
84        None
85    }
86}
87
88impl Sealed for ClaimChannelEndReply {}
89
90impl From<ClaimChannelEndReply> for Message {
91    fn from(msg: ClaimChannelEndReply) -> Self {
92        Self::ClaimChannelEndReply(msg)
93    }
94}
95
96#[cfg(test)]
97mod test {
98    use super::super::test::{assert_deserialize_eq, assert_serialize_eq};
99    use super::super::Message;
100    use super::{ClaimChannelEndReply, ClaimChannelEndResult};
101
102    #[test]
103    fn sender_claimed() {
104        let serialized = [8, 0, 0, 0, 25, 1, 0, 2];
105
106        let msg = ClaimChannelEndReply {
107            serial: 1,
108            result: ClaimChannelEndResult::SenderClaimed(2),
109        };
110        assert_serialize_eq(&msg, serialized);
111        assert_deserialize_eq(&msg, serialized);
112
113        let msg = Message::ClaimChannelEndReply(msg);
114        assert_serialize_eq(&msg, serialized);
115        assert_deserialize_eq(&msg, serialized);
116    }
117
118    #[test]
119    fn receiver_claimed() {
120        let serialized = [7, 0, 0, 0, 25, 1, 1];
121
122        let msg = ClaimChannelEndReply {
123            serial: 1,
124            result: ClaimChannelEndResult::ReceiverClaimed,
125        };
126        assert_serialize_eq(&msg, serialized);
127        assert_deserialize_eq(&msg, serialized);
128
129        let msg = Message::ClaimChannelEndReply(msg);
130        assert_serialize_eq(&msg, serialized);
131        assert_deserialize_eq(&msg, serialized);
132    }
133
134    #[test]
135    fn invalid_channel() {
136        let serialized = [7, 0, 0, 0, 25, 1, 2];
137
138        let msg = ClaimChannelEndReply {
139            serial: 1,
140            result: ClaimChannelEndResult::InvalidChannel,
141        };
142        assert_serialize_eq(&msg, serialized);
143        assert_deserialize_eq(&msg, serialized);
144
145        let msg = Message::ClaimChannelEndReply(msg);
146        assert_serialize_eq(&msg, serialized);
147        assert_deserialize_eq(&msg, serialized);
148    }
149
150    #[test]
151    fn already_claimed() {
152        let serialized = [7, 0, 0, 0, 25, 1, 3];
153
154        let msg = ClaimChannelEndReply {
155            serial: 1,
156            result: ClaimChannelEndResult::AlreadyClaimed,
157        };
158        assert_serialize_eq(&msg, serialized);
159        assert_deserialize_eq(&msg, serialized);
160
161        let msg = Message::ClaimChannelEndReply(msg);
162        assert_serialize_eq(&msg, serialized);
163        assert_deserialize_eq(&msg, serialized);
164    }
165}
aldrin_core/message/claim_channel_end_reply.rs

aldrin_core/message/
claim_channel_end_reply.rs
