aldrin_core/message/
claim_channel_end_reply.rs

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

aldrin_core/message/
claim_channel_end_reply.rs
