kaspa_utils/lib.rs
1//!
2//! # Kaspa Utilities
3//!
4//! General purpose utilities and various type extensions used across the Rusty Kaspa codebase.
5//!
6
7pub mod any;
8pub mod arc;
9pub mod binary_heap;
10pub mod channel;
11pub mod expiring_cache;
12pub mod hashmap;
13pub mod hex;
14pub mod iter;
15pub mod mem_size;
16pub mod networking;
17pub mod option;
18pub mod refs;
19
20pub mod as_slice;
21
22/// # Examples
23/// ## Implement serde::Serialize/serde::Deserialize for the Vec field of the struct
24/// ```
25/// #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
26/// struct MyStructVec {
27/// #[serde(with = "kaspa_utils::serde_bytes")]
28/// v: Vec<u8>,
29/// }
30/// let v = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
31/// let len = v.len();
32/// let test_struct = MyStructVec { v: v.clone() };
33///
34/// // Serialize using bincode
35/// let encoded = bincode::serialize(&test_struct).unwrap();
36/// assert_eq!(encoded, len.to_le_bytes().into_iter().chain(v.into_iter()).collect::<Vec<_>>());
37/// // Deserialize using bincode
38/// let decoded: MyStructVec = bincode::deserialize(&encoded).unwrap();
39/// assert_eq!(test_struct, decoded);
40///
41/// let expected_str = r#"{"v":"000102030405060708090a0b0c0d0e0f10111213"}"#;
42/// // Serialize using serde_json
43/// let json = serde_json::to_string(&test_struct).unwrap();
44/// assert_eq!(expected_str, json);
45/// // Deserialize using serde_json
46/// let from_json: MyStructVec = serde_json::from_str(&json).unwrap();
47/// assert_eq!(test_struct, from_json);
48/// ```
49/// ## Implement serde::Serialize/serde::Deserialize for the SmallVec field of the struct
50/// ```
51/// use smallvec::{smallvec, SmallVec};
52/// #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
53/// struct MyStructSmallVec {
54/// #[serde(with = "kaspa_utils::serde_bytes")]
55/// v: SmallVec<[u8; 19]>,
56/// }
57/// let v = smallvec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
58/// let len = v.len();
59/// let test_struct = MyStructSmallVec { v: v.clone() };
60///
61/// // Serialize using bincode
62/// let encoded = bincode::serialize(&test_struct).unwrap();
63/// assert_eq!(encoded, len.to_le_bytes().into_iter().chain(v.into_iter()).collect::<Vec<_>>());
64/// // Deserialize using bincode
65/// let decoded: MyStructSmallVec = bincode::deserialize(&encoded).unwrap();
66/// assert_eq!(test_struct, decoded);
67///
68/// let expected_str = r#"{"v":"000102030405060708090a0b0c0d0e0f10111213"}"#;
69/// // Serialize using serde_json
70/// let json = serde_json::to_string(&test_struct).unwrap();
71/// assert_eq!(expected_str, json);
72/// // Deserialize using serde_json
73/// let from_json: MyStructSmallVec = serde_json::from_str(&json).unwrap();
74/// assert_eq!(test_struct, from_json);
75/// ```
76pub mod serde_bytes;
77pub mod serde_bytes_optional;
78
79/// # Examples
80///
81/// ```
82/// #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
83/// struct TestStruct {
84/// #[serde(with = "kaspa_utils::serde_bytes_fixed")]
85/// v: [u8; 20],
86/// }
87/// let test_struct = TestStruct { v: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] };
88///
89/// // Serialize using bincode
90/// let encoded = bincode::serialize(&test_struct).unwrap();
91/// assert_eq!(encoded, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
92/// // Deserialize using bincode
93/// let decoded: TestStruct = bincode::deserialize(&encoded).unwrap();
94/// assert_eq!(test_struct, decoded);
95///
96/// let expected_str = r#"{"v":"000102030405060708090a0b0c0d0e0f10111213"}"#;
97/// // Serialize using serde_json
98/// let json = serde_json::to_string(&test_struct).unwrap();
99/// assert_eq!(expected_str, json);
100/// // Deserialize using serde_json
101/// let from_json: TestStruct = serde_json::from_str(&json).unwrap();
102/// assert_eq!(test_struct, from_json);
103/// ```
104pub mod serde_bytes_fixed;
105/// # Examples
106/// ## Implement serde::Serialize/serde::Deserialize using declarative macro
107/// ```
108/// #[derive(Debug, Copy, Clone, PartialEq, Eq)]
109/// struct MyStruct([u8; 20]);
110///
111/// impl AsRef<[u8; 20]> for MyStruct {
112/// fn as_ref(&self) -> &[u8; 20] {
113/// &self.0
114/// }
115/// }
116/// impl kaspa_utils::hex::FromHex for MyStruct {
117/// type Error = faster_hex::Error;
118/// fn from_hex(hex_str: &str) -> Result<Self, Self::Error> {
119/// let mut bytes = [0u8; 20];
120/// faster_hex::hex_decode(hex_str.as_bytes(), &mut bytes)?;
121/// Ok(MyStruct(bytes))
122/// }
123/// }
124/// impl From<[u8; 20]> for MyStruct {
125/// fn from(value: [u8; 20]) -> Self {
126/// MyStruct(value)
127/// }
128/// }
129/// kaspa_utils::serde_impl_ser_fixed_bytes_ref!(MyStruct, 20);
130/// kaspa_utils::serde_impl_deser_fixed_bytes_ref!(MyStruct, 20);
131///
132/// let test_struct = MyStruct([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
133/// let expected_str = r#""000102030405060708090a0b0c0d0e0f10111213""#;
134/// // Serialize using serde_json
135/// let json = serde_json::to_string(&test_struct).unwrap();
136/// assert_eq!(expected_str, json);
137/// // Deserialize using serde_json
138/// let from_json: MyStruct = serde_json::from_str(&json).unwrap();
139/// assert_eq!(test_struct, from_json);
140/// // Serialize using bincode
141/// let encoded = bincode::serialize(&test_struct).unwrap();
142/// assert_eq!(encoded, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
143/// // Deserialize using bincode
144/// let decoded: MyStruct = bincode::deserialize(&encoded).unwrap();
145/// assert_eq!(test_struct, decoded);
146/// ```
147///
148/// ## Implement serde::Serialize/serde::Deserialize for the field of the struct
149/// ```
150/// #[derive(Debug, Copy, Clone, PartialEq, Eq)]
151/// struct MyStruct([u8; 20]);
152///
153/// impl AsRef<[u8; 20]> for MyStruct {
154/// fn as_ref(&self) -> &[u8; 20] {
155/// &self.0
156/// }
157/// }
158/// impl kaspa_utils::hex::FromHex for MyStruct {
159/// type Error = faster_hex::Error;
160/// fn from_hex(hex_str: &str) -> Result<Self, Self::Error> {
161/// let mut bytes = [0u8; 20];
162/// faster_hex::hex_decode(hex_str.as_bytes(), &mut bytes)?;
163/// Ok(MyStruct(bytes))
164/// }
165/// }
166/// impl From<[u8; 20]> for MyStruct {
167/// fn from(value: [u8; 20]) -> Self {
168/// MyStruct(value)
169/// }
170/// }
171///
172/// #[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
173/// struct TestStruct {
174/// #[serde(with = "kaspa_utils::serde_bytes_fixed_ref")]
175/// v: MyStruct,
176/// }
177///
178/// let test_struct = TestStruct { v: MyStruct([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]) };
179///
180/// // Serialize using bincode
181/// let encoded = bincode::serialize(&test_struct).unwrap();
182/// assert_eq!(encoded, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
183/// // Deserialize using bincode
184/// let decoded: TestStruct = bincode::deserialize(&encoded).unwrap();
185/// assert_eq!(test_struct, decoded);
186///
187/// let expected_str = r#"{"v":"000102030405060708090a0b0c0d0e0f10111213"}"#;
188/// // Serialize using serde_json
189/// let json = serde_json::to_string(&test_struct).unwrap();
190/// assert_eq!(expected_str, json);
191/// // Deserialize using serde_json
192/// let from_json: TestStruct = serde_json::from_str(&json).unwrap();
193/// assert_eq!(test_struct, from_json);
194/// ```
195pub mod serde_bytes_fixed_ref;
196pub mod sim;
197pub mod sync;
198pub mod triggers;
199pub mod vec;
200
201pub mod git;
202
203#[cfg(not(target_arch = "wasm32"))]
204pub mod fd_budget;
205#[cfg(not(target_arch = "wasm32"))]
206pub mod sysinfo;