bulk_client/msgs/
mod.rs

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

bulk_client/msgs/
mod.rs
