1use serde::{Deserialize, Serialize};
2
3#[cfg(feature = "bitcoin")]
4use moonramp_core::bitcoin;
5#[cfg(feature = "monero")]
6use moonramp_core::monero;
7use moonramp_core::{anyhow, serde};
8#[cfg(feature = "entity")]
9use moonramp_entity::{currency, network, ticker, wallet};
10
11#[cfg(feature = "bitcoin")]
12mod bitcoin_wallet;
13#[cfg(feature = "bitcoin")]
14pub use bitcoin_wallet::*;
15
16#[cfg(feature = "monero")]
17mod monero_wallet;
18#[cfg(feature = "monero")]
19pub use monero_wallet::*;
20
21#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
22#[serde(crate = "moonramp_core::serde")]
23pub enum Ticker {
24 BCH,
25 BTC,
26 ETC,
27 ETH,
28 XMR,
29}
30
31#[cfg(feature = "entity")]
32impl From<Ticker> for ticker::Ticker {
33 fn from(t: Ticker) -> ticker::Ticker {
34 match t {
35 Ticker::BCH => ticker::Ticker::BCH,
36 Ticker::BTC => ticker::Ticker::BTC,
37 Ticker::ETC => ticker::Ticker::ETC,
38 Ticker::ETH => ticker::Ticker::ETH,
39 Ticker::XMR => ticker::Ticker::XMR,
40 }
41 }
42}
43
44#[cfg(feature = "entity")]
45impl From<&Ticker> for ticker::Ticker {
46 fn from(t: &Ticker) -> ticker::Ticker {
47 match t {
48 Ticker::BCH => ticker::Ticker::BCH,
49 Ticker::BTC => ticker::Ticker::BTC,
50 Ticker::ETC => ticker::Ticker::ETC,
51 Ticker::ETH => ticker::Ticker::ETH,
52 Ticker::XMR => ticker::Ticker::XMR,
53 }
54 }
55}
56
57#[cfg(feature = "entity")]
58impl From<ticker::Ticker> for Ticker {
59 fn from(t: ticker::Ticker) -> Ticker {
60 match t {
61 ticker::Ticker::BCH => Ticker::BCH,
62 ticker::Ticker::BTC => Ticker::BTC,
63 ticker::Ticker::ETC => Ticker::ETC,
64 ticker::Ticker::ETH => Ticker::ETH,
65 ticker::Ticker::XMR => Ticker::XMR,
66 }
67 }
68}
69
70#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
71#[serde(crate = "moonramp_core::serde")]
72pub enum Currency {
73 BCH,
74 BTC,
75 ETC,
76 ETH,
77 USDC,
78 USDP,
79 USDT,
80 XMR,
81}
82
83#[cfg(feature = "entity")]
84impl From<Currency> for currency::Currency {
85 fn from(c: Currency) -> currency::Currency {
86 match c {
87 Currency::BCH => currency::Currency::BCH,
88 Currency::BTC => currency::Currency::BTC,
89 Currency::ETC => currency::Currency::ETC,
90 Currency::ETH => currency::Currency::ETH,
91 Currency::USDC => currency::Currency::USDC,
92 Currency::USDP => currency::Currency::USDP,
93 Currency::USDT => currency::Currency::USDT,
94 Currency::XMR => currency::Currency::XMR,
95 }
96 }
97}
98
99#[cfg(feature = "entity")]
100impl From<&Currency> for currency::Currency {
101 fn from(c: &Currency) -> currency::Currency {
102 match c {
103 Currency::BCH => currency::Currency::BCH,
104 Currency::BTC => currency::Currency::BTC,
105 Currency::ETC => currency::Currency::ETC,
106 Currency::ETH => currency::Currency::ETH,
107 Currency::USDC => currency::Currency::USDC,
108 Currency::USDP => currency::Currency::USDP,
109 Currency::USDT => currency::Currency::USDT,
110 Currency::XMR => currency::Currency::XMR,
111 }
112 }
113}
114
115#[cfg(feature = "entity")]
116impl From<currency::Currency> for Currency {
117 fn from(c: currency::Currency) -> Currency {
118 match c {
119 currency::Currency::BCH => Currency::BCH,
120 currency::Currency::BTC => Currency::BTC,
121 currency::Currency::ETC => Currency::ETC,
122 currency::Currency::ETH => Currency::ETH,
123 currency::Currency::USDC => Currency::USDC,
124 currency::Currency::USDP => Currency::USDP,
125 currency::Currency::USDT => Currency::USDT,
126 currency::Currency::XMR => Currency::XMR,
127 }
128 }
129}
130
131#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
132#[serde(crate = "moonramp_core::serde")]
133pub enum Network {
134 Mainnet,
135 Testnet,
136 Regtest,
137}
138
139#[cfg(feature = "entity")]
140impl From<Network> for network::Network {
141 fn from(n: Network) -> network::Network {
142 match n {
143 Network::Mainnet => network::Network::Mainnet,
144 Network::Testnet => network::Network::Testnet,
145 Network::Regtest => network::Network::Regtest,
146 }
147 }
148}
149
150#[cfg(feature = "entity")]
151impl From<&Network> for network::Network {
152 fn from(n: &Network) -> network::Network {
153 match n {
154 Network::Mainnet => network::Network::Mainnet,
155 Network::Testnet => network::Network::Testnet,
156 Network::Regtest => network::Network::Regtest,
157 }
158 }
159}
160
161#[cfg(feature = "entity")]
162impl From<network::Network> for Network {
163 fn from(n: network::Network) -> Network {
164 match n {
165 network::Network::Mainnet => Network::Mainnet,
166 network::Network::Testnet => Network::Testnet,
167 network::Network::Regtest => Network::Regtest,
168 }
169 }
170}
171
172#[cfg(feature = "bitcoin")]
173impl From<Network> for bitcoin::Network {
174 fn from(n: Network) -> bitcoin::Network {
175 match n {
176 Network::Mainnet => bitcoin::Network::Bitcoin,
177 Network::Testnet => bitcoin::Network::Testnet,
178 Network::Regtest => bitcoin::Network::Regtest,
179 }
180 }
181}
182
183#[cfg(feature = "bitcoin")]
184impl From<&Network> for bitcoin::Network {
185 fn from(n: &Network) -> bitcoin::Network {
186 match n {
187 Network::Mainnet => bitcoin::Network::Bitcoin,
188 Network::Testnet => bitcoin::Network::Testnet,
189 Network::Regtest => bitcoin::Network::Regtest,
190 }
191 }
192}
193
194#[cfg(feature = "bitcoin")]
195impl From<&mut Network> for bitcoin::Network {
196 fn from(n: &mut Network) -> bitcoin::Network {
197 match n {
198 Network::Mainnet => bitcoin::Network::Bitcoin,
199 Network::Testnet => bitcoin::Network::Testnet,
200 Network::Regtest => bitcoin::Network::Regtest,
201 }
202 }
203}
204
205#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
206#[serde(crate = "moonramp_core::serde")]
207pub enum WalletType {
208 Hot,
209 Cold,
210}
211
212#[cfg(feature = "entity")]
213impl From<WalletType> for wallet::WalletType {
214 fn from(t: WalletType) -> wallet::WalletType {
215 match t {
216 WalletType::Hot => wallet::WalletType::Hot,
217 WalletType::Cold => wallet::WalletType::Cold,
218 }
219 }
220}
221
222#[cfg(feature = "entity")]
223impl From<&WalletType> for wallet::WalletType {
224 fn from(t: &WalletType) -> wallet::WalletType {
225 match t {
226 WalletType::Hot => wallet::WalletType::Hot,
227 WalletType::Cold => wallet::WalletType::Cold,
228 }
229 }
230}
231
232#[cfg(feature = "entity")]
233impl From<wallet::WalletType> for WalletType {
234 fn from(t: wallet::WalletType) -> WalletType {
235 match t {
236 wallet::WalletType::Hot => WalletType::Hot,
237 wallet::WalletType::Cold => WalletType::Cold,
238 }
239 }
240}
241
242#[cfg(feature = "bitcoin")]
243#[derive(Clone, Debug, Deserialize, Serialize)]
244#[serde(crate = "moonramp_core::serde", rename_all = "UPPERCASE")]
245pub enum BitcoinColdWalletType {
246 XPubkey,
247 }
251
252#[derive(Debug, Eq, PartialEq, Deserialize, Serialize)]
253#[serde(crate = "moonramp_core::serde")]
254pub enum Wallet {
255 #[cfg(feature = "bitcoin")]
256 Bitcoin(bitcoin_wallet::BitcoinWallet),
257}
258
259impl Wallet {
260 pub fn pubkey(&self) -> String {
261 match self {
262 #[cfg(feature = "bitcoin")]
263 Wallet::Bitcoin(w) => w.pubkey(),
264 }
265 }
266
267 pub fn ticker(&self) -> Ticker {
268 match self {
269 #[cfg(feature = "bitcoin")]
270 Wallet::Bitcoin(w) => w.ticker(),
271 }
272 }
273
274 pub fn network(&self) -> Network {
275 match self {
276 #[cfg(feature = "bitcoin")]
277 Wallet::Bitcoin(w) => w.network(),
278 }
279 }
280
281 pub fn wallet_type(&self) -> WalletType {
282 match self {
283 #[cfg(feature = "bitcoin")]
284 Wallet::Bitcoin(w) => w.wallet_type(),
285 }
286 }
287}
288
289#[cfg(feature = "bitcoin")]
290impl Wallet {
291 pub fn is_bitcoin(&self) -> bool {
292 match self {
293 Wallet::Bitcoin(_) => true,
294 #[allow(unreachable_patterns)]
295 _ => false,
296 }
297 }
298
299 pub fn into_bitcoin(self) -> anyhow::Result<bitcoin_wallet::BitcoinWallet, Self> {
300 match self {
301 Wallet::Bitcoin(w) => Ok(w),
302 #[allow(unreachable_patterns)]
303 _ => Err(self),
304 }
305 }
306}