stripe_shared/
payment_method_details_crypto.rs

1#[derive(Clone, Debug)]
2#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
3#[cfg_attr(feature = "deserialize", derive(serde::Deserialize))]
4pub struct PaymentMethodDetailsCrypto {
5    /// The wallet address of the customer.
6    pub buyer_address: Option<String>,
7    /// The blockchain network that the transaction was sent on.
8    pub network: Option<PaymentMethodDetailsCryptoNetwork>,
9    /// The token currency that the transaction was sent with.
10    pub token_currency: Option<PaymentMethodDetailsCryptoTokenCurrency>,
11    /// The blockchain transaction hash of the crypto payment.
12    pub transaction_hash: Option<String>,
13}
14#[doc(hidden)]
15pub struct PaymentMethodDetailsCryptoBuilder {
16    buyer_address: Option<Option<String>>,
17    network: Option<Option<PaymentMethodDetailsCryptoNetwork>>,
18    token_currency: Option<Option<PaymentMethodDetailsCryptoTokenCurrency>>,
19    transaction_hash: Option<Option<String>>,
20}
21
22#[allow(
23    unused_variables,
24    irrefutable_let_patterns,
25    clippy::let_unit_value,
26    clippy::match_single_binding,
27    clippy::single_match
28)]
29const _: () = {
30    use miniserde::de::{Map, Visitor};
31    use miniserde::json::Value;
32    use miniserde::{Deserialize, Result, make_place};
33    use stripe_types::miniserde_helpers::FromValueOpt;
34    use stripe_types::{MapBuilder, ObjectDeser};
35
36    make_place!(Place);
37
38    impl Deserialize for PaymentMethodDetailsCrypto {
39        fn begin(out: &mut Option<Self>) -> &mut dyn Visitor {
40            Place::new(out)
41        }
42    }
43
44    struct Builder<'a> {
45        out: &'a mut Option<PaymentMethodDetailsCrypto>,
46        builder: PaymentMethodDetailsCryptoBuilder,
47    }
48
49    impl Visitor for Place<PaymentMethodDetailsCrypto> {
50        fn map(&mut self) -> Result<Box<dyn Map + '_>> {
51            Ok(Box::new(Builder {
52                out: &mut self.out,
53                builder: PaymentMethodDetailsCryptoBuilder::deser_default(),
54            }))
55        }
56    }
57
58    impl MapBuilder for PaymentMethodDetailsCryptoBuilder {
59        type Out = PaymentMethodDetailsCrypto;
60        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
61            Ok(match k {
62                "buyer_address" => Deserialize::begin(&mut self.buyer_address),
63                "network" => Deserialize::begin(&mut self.network),
64                "token_currency" => Deserialize::begin(&mut self.token_currency),
65                "transaction_hash" => Deserialize::begin(&mut self.transaction_hash),
66                _ => <dyn Visitor>::ignore(),
67            })
68        }
69
70        fn deser_default() -> Self {
71            Self {
72                buyer_address: Deserialize::default(),
73                network: Deserialize::default(),
74                token_currency: Deserialize::default(),
75                transaction_hash: Deserialize::default(),
76            }
77        }
78
79        fn take_out(&mut self) -> Option<Self::Out> {
80            let (Some(buyer_address), Some(network), Some(token_currency), Some(transaction_hash)) = (
81                self.buyer_address.take(),
82                self.network,
83                self.token_currency,
84                self.transaction_hash.take(),
85            ) else {
86                return None;
87            };
88            Some(Self::Out { buyer_address, network, token_currency, transaction_hash })
89        }
90    }
91
92    impl Map for Builder<'_> {
93        fn key(&mut self, k: &str) -> Result<&mut dyn Visitor> {
94            self.builder.key(k)
95        }
96
97        fn finish(&mut self) -> Result<()> {
98            *self.out = self.builder.take_out();
99            Ok(())
100        }
101    }
102
103    impl ObjectDeser for PaymentMethodDetailsCrypto {
104        type Builder = PaymentMethodDetailsCryptoBuilder;
105    }
106
107    impl FromValueOpt for PaymentMethodDetailsCrypto {
108        fn from_value(v: Value) -> Option<Self> {
109            let Value::Object(obj) = v else {
110                return None;
111            };
112            let mut b = PaymentMethodDetailsCryptoBuilder::deser_default();
113            for (k, v) in obj {
114                match k.as_str() {
115                    "buyer_address" => b.buyer_address = FromValueOpt::from_value(v),
116                    "network" => b.network = FromValueOpt::from_value(v),
117                    "token_currency" => b.token_currency = FromValueOpt::from_value(v),
118                    "transaction_hash" => b.transaction_hash = FromValueOpt::from_value(v),
119                    _ => {}
120                }
121            }
122            b.take_out()
123        }
124    }
125};
126/// The blockchain network that the transaction was sent on.
127#[derive(Copy, Clone, Eq, PartialEq)]
128pub enum PaymentMethodDetailsCryptoNetwork {
129    Base,
130    Ethereum,
131    Polygon,
132    Solana,
133}
134impl PaymentMethodDetailsCryptoNetwork {
135    pub fn as_str(self) -> &'static str {
136        use PaymentMethodDetailsCryptoNetwork::*;
137        match self {
138            Base => "base",
139            Ethereum => "ethereum",
140            Polygon => "polygon",
141            Solana => "solana",
142        }
143    }
144}
145
146impl std::str::FromStr for PaymentMethodDetailsCryptoNetwork {
147    type Err = stripe_types::StripeParseError;
148    fn from_str(s: &str) -> Result<Self, Self::Err> {
149        use PaymentMethodDetailsCryptoNetwork::*;
150        match s {
151            "base" => Ok(Base),
152            "ethereum" => Ok(Ethereum),
153            "polygon" => Ok(Polygon),
154            "solana" => Ok(Solana),
155            _ => Err(stripe_types::StripeParseError),
156        }
157    }
158}
159impl std::fmt::Display for PaymentMethodDetailsCryptoNetwork {
160    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
161        f.write_str(self.as_str())
162    }
163}
164
165impl std::fmt::Debug for PaymentMethodDetailsCryptoNetwork {
166    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
167        f.write_str(self.as_str())
168    }
169}
170#[cfg(feature = "serialize")]
171impl serde::Serialize for PaymentMethodDetailsCryptoNetwork {
172    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
173    where
174        S: serde::Serializer,
175    {
176        serializer.serialize_str(self.as_str())
177    }
178}
179impl miniserde::Deserialize for PaymentMethodDetailsCryptoNetwork {
180    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
181        crate::Place::new(out)
182    }
183}
184
185impl miniserde::de::Visitor for crate::Place<PaymentMethodDetailsCryptoNetwork> {
186    fn string(&mut self, s: &str) -> miniserde::Result<()> {
187        use std::str::FromStr;
188        self.out =
189            Some(PaymentMethodDetailsCryptoNetwork::from_str(s).map_err(|_| miniserde::Error)?);
190        Ok(())
191    }
192}
193
194stripe_types::impl_from_val_with_from_str!(PaymentMethodDetailsCryptoNetwork);
195#[cfg(feature = "deserialize")]
196impl<'de> serde::Deserialize<'de> for PaymentMethodDetailsCryptoNetwork {
197    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
198        use std::str::FromStr;
199        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
200        Self::from_str(&s).map_err(|_| {
201            serde::de::Error::custom("Unknown value for PaymentMethodDetailsCryptoNetwork")
202        })
203    }
204}
205/// The token currency that the transaction was sent with.
206#[derive(Copy, Clone, Eq, PartialEq)]
207pub enum PaymentMethodDetailsCryptoTokenCurrency {
208    Usdc,
209    Usdg,
210    Usdp,
211}
212impl PaymentMethodDetailsCryptoTokenCurrency {
213    pub fn as_str(self) -> &'static str {
214        use PaymentMethodDetailsCryptoTokenCurrency::*;
215        match self {
216            Usdc => "usdc",
217            Usdg => "usdg",
218            Usdp => "usdp",
219        }
220    }
221}
222
223impl std::str::FromStr for PaymentMethodDetailsCryptoTokenCurrency {
224    type Err = stripe_types::StripeParseError;
225    fn from_str(s: &str) -> Result<Self, Self::Err> {
226        use PaymentMethodDetailsCryptoTokenCurrency::*;
227        match s {
228            "usdc" => Ok(Usdc),
229            "usdg" => Ok(Usdg),
230            "usdp" => Ok(Usdp),
231            _ => Err(stripe_types::StripeParseError),
232        }
233    }
234}
235impl std::fmt::Display for PaymentMethodDetailsCryptoTokenCurrency {
236    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
237        f.write_str(self.as_str())
238    }
239}
240
241impl std::fmt::Debug for PaymentMethodDetailsCryptoTokenCurrency {
242    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
243        f.write_str(self.as_str())
244    }
245}
246#[cfg(feature = "serialize")]
247impl serde::Serialize for PaymentMethodDetailsCryptoTokenCurrency {
248    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
249    where
250        S: serde::Serializer,
251    {
252        serializer.serialize_str(self.as_str())
253    }
254}
255impl miniserde::Deserialize for PaymentMethodDetailsCryptoTokenCurrency {
256    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
257        crate::Place::new(out)
258    }
259}
260
261impl miniserde::de::Visitor for crate::Place<PaymentMethodDetailsCryptoTokenCurrency> {
262    fn string(&mut self, s: &str) -> miniserde::Result<()> {
263        use std::str::FromStr;
264        self.out = Some(
265            PaymentMethodDetailsCryptoTokenCurrency::from_str(s).map_err(|_| miniserde::Error)?,
266        );
267        Ok(())
268    }
269}
270
271stripe_types::impl_from_val_with_from_str!(PaymentMethodDetailsCryptoTokenCurrency);
272#[cfg(feature = "deserialize")]
273impl<'de> serde::Deserialize<'de> for PaymentMethodDetailsCryptoTokenCurrency {
274    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
275        use std::str::FromStr;
276        let s: std::borrow::Cow<'de, str> = serde::Deserialize::deserialize(deserializer)?;
277        Self::from_str(&s).map_err(|_| {
278            serde::de::Error::custom("Unknown value for PaymentMethodDetailsCryptoTokenCurrency")
279        })
280    }
281}
stripe_shared/payment_method_details_crypto.rs

stripe_shared/
payment_method_details_crypto.rs
