kaspa_notify/
scope.rs

1use super::events::EventType;
2use borsh::{BorshDeserialize, BorshSerialize};
3use derive_more::Display;
4use kaspa_addresses::Address;
5use serde::{Deserialize, Serialize};
6use workflow_serializer::prelude::*;
7
8macro_rules! scope_enum {
9    ($(#[$meta:meta])* $vis:vis enum $name:ident {
10    $($(#[$variant_meta:meta])* $variant_name:ident,)*
11    }) => {
12        paste::paste! {
13            $(#[$meta])*
14            $vis enum $name {
15                $($(#[$variant_meta])* $variant_name([<$variant_name Scope>])),*
16            }
17
18            impl std::convert::From<EventType> for $name {
19                fn from(value: EventType) -> Self {
20                    match value {
21                        $(EventType::$variant_name => $name::$variant_name(kaspa_notify::scope::[<$variant_name Scope>]::default())),*
22                    }
23                }
24            }
25
26            $(impl std::convert::From<[<$variant_name Scope>]> for Scope {
27                fn from(value: [<$variant_name Scope>]) -> Self {
28                    Scope::$variant_name(value)
29                }
30            })*
31        }
32    }
33}
34
35scope_enum! {
36/// Subscription scope for every event type
37#[derive(Clone, Display, Debug, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
38pub enum Scope {
39    BlockAdded,
40    VirtualChainChanged,
41    FinalityConflict,
42    FinalityConflictResolved,
43    UtxosChanged,
44    SinkBlueScoreChanged,
45    VirtualDaaScoreChanged,
46    PruningPointUtxoSetOverride,
47    NewBlockTemplate,
48}
49}
50
51impl Scope {
52    pub fn event_type(&self) -> EventType {
53        self.into()
54    }
55}
56
57impl Serializer for Scope {
58    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
59        store!(u16, &1, writer)?;
60        store!(Scope, self, writer)?;
61        Ok(())
62    }
63}
64
65impl Deserializer for Scope {
66    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
67        let _version = load!(u16, reader)?;
68        load!(Scope, reader)
69    }
70}
71
72#[derive(Clone, Display, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
73pub struct BlockAddedScope {}
74
75impl Serializer for BlockAddedScope {
76    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
77        store!(u16, &1, writer)?;
78        Ok(())
79    }
80}
81
82impl Deserializer for BlockAddedScope {
83    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
84        let _version = load!(u16, reader)?;
85        Ok(Self {})
86    }
87}
88
89#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
90pub struct VirtualChainChangedScope {
91    pub include_accepted_transaction_ids: bool,
92}
93
94impl VirtualChainChangedScope {
95    pub fn new(include_accepted_transaction_ids: bool) -> Self {
96        Self { include_accepted_transaction_ids }
97    }
98}
99
100impl std::fmt::Display for VirtualChainChangedScope {
101    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
102        write!(f, "VirtualChainChangedScope{}", if self.include_accepted_transaction_ids { " with accepted transactions" } else { "" })
103    }
104}
105
106impl Serializer for VirtualChainChangedScope {
107    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
108        store!(u16, &1, writer)?;
109        store!(bool, &self.include_accepted_transaction_ids, writer)?;
110        Ok(())
111    }
112}
113
114impl Deserializer for VirtualChainChangedScope {
115    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
116        let _version = load!(u16, reader)?;
117        let include_accepted_transaction_ids = load!(bool, reader)?;
118        Ok(Self { include_accepted_transaction_ids })
119    }
120}
121
122#[derive(Clone, Display, Debug, PartialEq, Eq, Default, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
123pub struct FinalityConflictScope {}
124
125impl Serializer for FinalityConflictScope {
126    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
127        store!(u16, &1, writer)?;
128        Ok(())
129    }
130}
131
132impl Deserializer for FinalityConflictScope {
133    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
134        let _version = load!(u16, reader)?;
135        Ok(Self {})
136    }
137}
138
139#[derive(Clone, Display, Debug, PartialEq, Eq, Default, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
140pub struct FinalityConflictResolvedScope {}
141
142impl Serializer for FinalityConflictResolvedScope {
143    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
144        store!(u16, &1, writer)?;
145        Ok(())
146    }
147}
148
149impl Deserializer for FinalityConflictResolvedScope {
150    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
151        let _version = load!(u16, reader)?;
152        Ok(Self {})
153    }
154}
155
156#[derive(Clone, Debug, Default, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
157pub struct UtxosChangedScope {
158    pub addresses: Vec<Address>,
159}
160
161impl std::fmt::Display for UtxosChangedScope {
162    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
163        let addresses = match self.addresses.len() {
164            0 => "all".to_string(),
165            1 => format!("{}", self.addresses[0]),
166            n => format!("{} addresses", n),
167        };
168        write!(f, "UtxosChangedScope ({})", addresses)
169    }
170}
171
172impl PartialEq for UtxosChangedScope {
173    fn eq(&self, other: &Self) -> bool {
174        self.addresses.len() == other.addresses.len() && self.addresses.iter().all(|x| other.addresses.contains(x))
175    }
176}
177
178impl Eq for UtxosChangedScope {}
179
180impl UtxosChangedScope {
181    pub fn new(addresses: Vec<Address>) -> Self {
182        Self { addresses }
183    }
184}
185
186impl Serializer for UtxosChangedScope {
187    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
188        store!(u16, &1, writer)?;
189        store!(Vec<Address>, &self.addresses, writer)?;
190        Ok(())
191    }
192}
193
194impl Deserializer for UtxosChangedScope {
195    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
196        let _version = load!(u16, reader)?;
197        let addresses = load!(Vec<Address>, reader)?;
198        Ok(Self { addresses })
199    }
200}
201
202#[derive(Clone, Display, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
203pub struct SinkBlueScoreChangedScope {}
204
205impl Serializer for SinkBlueScoreChangedScope {
206    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
207        store!(u16, &1, writer)?;
208        Ok(())
209    }
210}
211
212impl Deserializer for SinkBlueScoreChangedScope {
213    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
214        let _version = load!(u16, reader)?;
215        Ok(Self {})
216    }
217}
218
219#[derive(Clone, Display, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
220pub struct VirtualDaaScoreChangedScope {}
221
222impl Serializer for VirtualDaaScoreChangedScope {
223    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
224        store!(u16, &1, writer)?;
225        Ok(())
226    }
227}
228
229impl Deserializer for VirtualDaaScoreChangedScope {
230    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
231        let _version = load!(u16, reader)?;
232        Ok(Self {})
233    }
234}
235
236#[derive(Clone, Display, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
237pub struct PruningPointUtxoSetOverrideScope {}
238
239impl Serializer for PruningPointUtxoSetOverrideScope {
240    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
241        store!(u16, &1, writer)?;
242        Ok(())
243    }
244}
245
246impl Deserializer for PruningPointUtxoSetOverrideScope {
247    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
248        let _version = load!(u16, reader)?;
249        Ok(Self {})
250    }
251}
252
253#[derive(Clone, Display, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshSerialize, BorshDeserialize)]
254pub struct NewBlockTemplateScope {}
255
256impl Serializer for NewBlockTemplateScope {
257    fn serialize<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<()> {
258        store!(u16, &1, writer)?;
259        Ok(())
260    }
261}
262
263impl Deserializer for NewBlockTemplateScope {
264    fn deserialize<R: std::io::Read>(reader: &mut R) -> std::io::Result<Self> {
265        let _version = load!(u16, reader)?;
266        Ok(Self {})
267    }
268}
kaspa_notify/scope.rs

kaspa_notify/
scope.rs
