bulk_client/msgs/
mod.rs

1pub mod md;
2pub mod subscription;
3pub mod account;
4pub mod responses;
5pub mod meta;
6pub mod oracle;
7pub mod order;
8pub mod conditional;
9pub mod multisig;
10pub mod subaccounts;
11
12pub use md::*;
13pub use subscription::*;
14pub use account::*;
15pub use responses::*;
16pub use meta::*;
17pub use oracle::*;
18pub use order::*;
19
20pub(crate) mod serde_hash {
21    use serde::{Deserialize, Deserializer, Serialize, Serializer};
22    use solana_hash::Hash;
23    use std::str::FromStr;
24
25    pub fn serialize<S: Serializer>(val: &Hash, serializer: S) -> Result<S::Ok, S::Error> {
26        if serializer.is_human_readable() {
27            serializer.serialize_str(&val.to_string())
28        } else {
29            val.as_bytes().serialize(serializer)
30        }
31    }
32
33    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Hash, D::Error> {
34        if deserializer.is_human_readable() {
35            let s = String::deserialize(deserializer)?;
36            Hash::from_str(&s).map_err(|e| serde::de::Error::custom(e.to_string()))
37        } else {
38            let bytes = <Vec<u8>>::deserialize(deserializer)?;
39            let arr: [u8; 32] = bytes
40                .try_into()
41                .map_err(|_| serde::de::Error::custom("expected 32 bytes for Hash"))?;
42            Ok(Hash::new_from_array(arr))
43        }
44    }
45}
46
47pub(crate) mod serde_pubkey {
48    use serde::{Deserialize, Deserializer, Serialize, Serializer};
49    use solana_pubkey::Pubkey;
50    use std::str::FromStr;
51
52    pub fn serialize<S: Serializer>(val: &Pubkey, serializer: S) -> Result<S::Ok, S::Error> {
53        if serializer.is_human_readable() {
54            serializer.serialize_str(&val.to_string())
55        } else {
56            val.as_array().serialize(serializer)
57        }
58    }
59
60    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Pubkey, D::Error> {
61        if deserializer.is_human_readable() {
62            let s = String::deserialize(deserializer)?;
63            Pubkey::from_str(&s).map_err(|e| serde::de::Error::custom(e.to_string()))
64        } else {
65            let bytes = <Vec<u8>>::deserialize(deserializer)?;
66            let arr: [u8; 32] = bytes
67                .try_into()
68                .map_err(|_| serde::de::Error::custom("expected 32 bytes for Pubkey"))?;
69            Ok(Pubkey::from(arr))
70        }
71    }
72}
73
74pub(crate) mod serde_signature {
75    use serde::{Deserialize, Deserializer, Serialize, Serializer};
76    use solana_signature::Signature;
77    use std::str::FromStr;
78
79    pub fn serialize<S: Serializer>(val: &Signature, serializer: S) -> Result<S::Ok, S::Error> {
80        if serializer.is_human_readable() {
81            serializer.serialize_str(&val.to_string())
82        } else {
83            val.as_array().serialize(serializer)
84        }
85    }
86
87    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Signature, D::Error> {
88        if deserializer.is_human_readable() {
89            let s = String::deserialize(deserializer)?;
90            Signature::from_str(&s).map_err(|e| serde::de::Error::custom(e.to_string()))
91        } else {
92            let bytes = <Vec<u8>>::deserialize(deserializer)?;
93            let arr: [u8; 64] = bytes
94                .try_into()
95                .map_err(|_| serde::de::Error::custom("expected 64 bytes for Signature"))?;
96            Ok(Signature::from(arr))
97        }
98    }
99}
100
101pub(crate) mod fixed_point {
102    use serde::{Deserialize, Deserializer, Serializer};
103
104    const SCALE: f64 = 1e8;
105
106    pub fn serialize<S: Serializer>(val: &f64, serializer: S) -> Result<S::Ok, S::Error> {
107        if serializer.is_human_readable() {
108            serializer.serialize_f64(*val)
109        } else {
110            let fixed = (val * SCALE).round() as u64;
111            serializer.serialize_u64(fixed)
112        }
113    }
114
115    pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<f64, D::Error> {
116        if deserializer.is_human_readable() {
117            f64::deserialize(deserializer)
118        } else {
119            let fixed = u64::deserialize(deserializer)?;
120            Ok(fixed as f64 / SCALE)
121        }
122    }
123}
124
125pub(crate) mod opt_fixed_point {
126    use serde::de::Visitor;
127    use serde::{de, Deserialize, Deserializer, Serializer};
128    use std::fmt;
129
130    const SCALE: f64 = 1e8;
131
132    pub fn serialize<S: Serializer>(val: &Option<f64>, serializer: S) -> Result<S::Ok, S::Error> {
133        match val {
134            None => serializer.serialize_none(),
135            Some(v) => {
136                if serializer.is_human_readable() {
137                    serializer.serialize_str(&v.to_string())
138                } else {
139                    let fixed = (v * SCALE).round() as u64;
140                    serializer.serialize_some(&fixed)
141                }
142            }
143        }
144    }
145
146    pub fn deserialize<'de, D: Deserializer<'de>>(
147        deserializer: D,
148    ) -> Result<Option<f64>, D::Error> {
149        deserializer.deserialize_any(OptF64Visitor)
150    }
151
152    struct OptF64Visitor;
153
154    impl<'de> Visitor<'de> for OptF64Visitor {
155        type Value = Option<f64>;
156
157        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
158            formatter.write_str("an optional f64 as a string, float, integer, or null/absent")
159        }
160
161        // JSON null or binary None tag
162        fn visit_none<E: de::Error>(self) -> Result<Option<f64>, E> {
163            Ok(None)
164        }
165
166        // serde unit type (e.g. MessagePack nil)
167        fn visit_unit<E: de::Error>(self) -> Result<Option<f64>, E> {
168            Ok(None)
169        }
170
171        // Binary Some(T) — inner deserializer carries the fixed-point u64
172        fn visit_some<D2: Deserializer<'de>>(
173            self,
174            deserializer: D2,
175        ) -> Result<Option<f64>, D2::Error> {
176            if deserializer.is_human_readable() {
177                // Shouldn't normally reach here for JSON, but be safe
178                deserializer.deserialize_any(OptF64Visitor)
179            } else {
180                let fixed = u64::deserialize(deserializer)?;
181                Ok(Some(fixed as f64 / SCALE))
182            }
183        }
184
185        fn visit_f64<E: de::Error>(self, val: f64) -> Result<Option<f64>, E> {
186            Ok(Some(val))
187        }
188
189        fn visit_f32<E: de::Error>(self, val: f32) -> Result<Option<f64>, E> {
190            Ok(Some(val as f64))
191        }
192
193        fn visit_u64<E: de::Error>(self, val: u64) -> Result<Option<f64>, E> {
194            Ok(Some(val as f64))
195        }
196
197        fn visit_i64<E: de::Error>(self, val: i64) -> Result<Option<f64>, E> {
198            Ok(Some(val as f64))
199        }
200
201        fn visit_str<E: de::Error>(self, val: &str) -> Result<Option<f64>, E> {
202            val.parse::<f64>()
203                .map(Some)
204                .map_err(|_| E::custom(format!("invalid f64 string: \"{val}\"")))
205        }
206
207        fn visit_string<E: de::Error>(self, val: String) -> Result<Option<f64>, E> {
208            self.visit_str(&val)
209        }
210    }
211}
bulk_client/msgs/mod.rs

bulk_client/msgs/
mod.rs
