Add support for gettin ghistorical price

Signed-off-by: Yuki Kishimoto <yukikishimoto@protonmail.com>

Author: yukibtc

src/client.rs

@@ -9,11 +9,38 @@ use crate::builder::MempoolClientBuilder;
 use crate::error::Error;
 use crate::response::{
     AddressStats, BlockInfo, BlockInfoV1, DifficultyAdjustment, FeeRecommendations, HashrateStats,
-    MempoolBlockFees, MempoolResponse, MempoolStats, Prices,
+    HistoricalPrice, MempoolBlockFees, MempoolResponse, MempoolStats, Prices,
 };
 #[cfg(feature = "ws")]
 use crate::websocket::{self, MempoolSubscription, MempoolSubscriptionRequest};
 
+/// Currency
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Currency {
+    USD,
+    EUR,
+    GBP,
+    CAD,
+    CHF,
+    AUD,
+    JPY,
+}
+
+impl Currency {
+    fn as_str(&self) -> &str {
+        match self {
+            Self::USD => "USD",
+            Self::EUR => "EUR",
+            Self::GBP => "GBP",
+            Self::CAD => "CAD",
+            Self::CHF => "CHF",
+            Self::AUD => "AUD",
+            Self::JPY => "JPY",
+        }
+    }
+}
+
 /// Hashrate time period
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum HashratePeriod {
@@ -108,6 +135,22 @@ impl MempoolClient {
         self.get_response(url).await
     }
 
+    /// Get historical price
+    pub async fn historical_price(
+        &self,
+        currency: Currency,
+        timestamp: u64,
+    ) -> Result<HistoricalPrice, Error> {
+        let mut url: Url = self.url.join("/api/v1/historical-price")?;
+
+        // Set query string
+        let query: String = format!("currency={}&timestamp={timestamp}", currency.as_str());
+        url.set_query(Some(&query));
+
+        // Get response
+        self.get_response(url).await
+    }
+
     /// Get details about an address.
     pub async fn get_address(&self, address: &Address) -> Result<AddressStats, Error> {
         let url: Url = self

src/response.rs

@@ -1,7 +1,7 @@
 //! Responses
 
 use std::cmp::Ordering;
-use std::collections::BTreeSet;
+use std::collections::{BTreeSet, HashMap};
 
 use bitcoin::address::{Address, NetworkUnchecked};
 use bitcoin::{Amount, BlockHash, FeeRate, TxMerkleNode, Weight};
@@ -32,32 +32,42 @@ impl<T> MempoolResponse<T> {
 }
 
 /// Prices
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Deserialize)]
 pub struct Prices {
     /// Timestamp
     #[serde(rename = "time")]
     pub timestamp: u64,
     /// USD
     #[serde(rename = "USD")]
-    pub usd: u32,
+    pub usd: f64,
     /// EUR
     #[serde(rename = "EUR")]
-    pub eur: u32,
+    pub eur: Option<f64>,
     /// GBP
     #[serde(rename = "GBP")]
-    pub gbp: u32,
+    pub gbp: Option<f64>,
     /// CAD
     #[serde(rename = "CAD")]
-    pub cad: u32,
+    pub cad: Option<f64>,
     /// CHF
     #[serde(rename = "CHF")]
-    pub chf: u32,
+    pub chf: Option<f64>,
     /// AUD
     #[serde(rename = "AUD")]
-    pub aud: u32,
+    pub aud: Option<f64>,
     /// JPY
     #[serde(rename = "JPY")]
-    pub jpy: u32,
+    pub jpy: Option<f64>,
+}
+
+/// Historical price
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+pub struct HistoricalPrice {
+    /// Prices
+    pub prices: Vec<Prices>,
+    /// Exchange rates
+    #[serde(rename = "exchangeRates")]
+    pub rates: HashMap<String, f64>,
 }
 
 /// Bitcoin difficulty adjustment information
@@ -881,4 +891,51 @@ mod tests {
         };
         assert_eq!(stats.avg_fee_rate(), FeeRate::from_sat_per_vb_unchecked(10));
     }
+
+    #[test]
+    fn test_historical_price_deserialization() {
+        let json = r#"{
+  "prices": [
+    {
+      "time": 1499904000,
+      "EUR": 1964,
+      "USD": 2254.9
+    }
+  ],
+  "exchangeRates": {
+    "USDEUR": 0.92,
+    "USDGBP": 0.78,
+    "USDCAD": 1.36,
+    "USDCHF": 0.89,
+    "USDAUD": 1.53,
+    "USDJPY": 149.48
+  }
+}
+"#;
+
+        let historical_price: HistoricalPrice = serde_json::from_str(json).unwrap();
+        assert_eq!(
+            historical_price,
+            HistoricalPrice {
+                prices: vec![Prices {
+                    timestamp: 1499904000,
+                    usd: 2254.9,
+                    eur: Some(1964.0),
+                    gbp: None,
+                    cad: None,
+                    chf: None,
+                    aud: None,
+                    jpy: None,
+                }],
+                rates: HashMap::from([
+                    ("USDEUR".to_string(), 0.92),
+                    ("USDGBP".to_string(), 0.78),
+                    ("USDCAD".to_string(), 1.36),
+                    ("USDCHF".to_string(), 0.89),
+                    ("USDAUD".to_string(), 1.53),
+                    ("USDJPY".to_string(), 149.48),
+                ]),
+            }
+        )
+    }
 }