Merge pull request #189 from PortalTechnologiesInc/wheatley/issue-129-fallback-only

fix(rates): fallback-only market source failover

Author: denmeh

CHANGELOG.md

@@ -12,6 +12,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 #### Added
 - `MessageRouter` now exposes `SendOutcome` / `EventSendResult` from the underlying `portal` crate, giving relay delivery feedback per event. `SendOutcome::Delivered { relays }` includes the URLs of relays that accepted the event. Not yet surfaced on the REST API; wiring will follow in a future release (#85)
+- `portal-rates`: added fallback-only market source failover in `MarketAPI` (tries fallback providers when the primary source fails). No `fiatUnits` mapping changes in this update (#129).
 
 ---
 
@@ -100,6 +101,7 @@ First release — Docker image available at [`getportal/sdk-daemon`](https://hub
 
 #### Added
 - `MessageRouter::add_conversation`, `add_conversation_with_relays` and `add_and_subscribe` now return `Vec<EventSendResult>` alongside their existing values, pairing each broadcasted Nostr event ID with a `SendOutcome`. `Delivered { relays }` includes the list of relay URLs that accepted the event; `Queued` means no relay was available (event queued for retry); `Dropped` means the queue was full. Callers can now detect when a command is silently queued because no relay is connected (#85). Existing mobile app behavior is preserved — outcomes are currently ignored, ready to be wired into the UI when needed.
+- `portal-rates`: added fallback-only market source failover in `MarketAPI` (tries fallback providers when the primary source fails). No `fiatUnits` mapping changes in this update (#129).
 
 #### Changed
 - `register_nip05()` now delegates to `portal::register_nip05()` (moved to `portal` crate). UniFFI bindings unchanged.

crates/portal-rates/src/lib.rs

@@ -69,7 +69,7 @@ struct FiatUnit {
     // country: Option<String>,
 }
 
-#[derive(Debug, Deserialize, Clone)]
+#[derive(Debug, Deserialize, Clone, Copy, PartialEq, Eq, Hash)]
 #[cfg_attr(feature = "bindings", derive(uniffi::Enum))]
 enum Source {
     Yadio,
@@ -242,8 +242,12 @@ impl MarketAPI {
         }
     }
 
-    async fn fetch_price(self: Arc<Self>, unit: &FiatUnit) -> Result<Option<String>, RatesError> {
-        let url = Self::build_url(&unit.source, &unit.end_point_key);
+    async fn fetch_price_for_source(
+        self: Arc<Self>,
+        source: &Source,
+        key: &str,
+    ) -> Result<Option<String>, RatesError> {
+        let url = Self::build_url(source, key);
         let res = self
             .client
             .get(&url)
@@ -259,10 +263,86 @@ impl MarketAPI {
             .text()
             .await
             .map_err(|e| RatesError::HttpRequest(e.to_string()))?;
-        let parsed = Self::parse_price_json(&text, &unit.source, &unit.end_point_key)?;
+        let parsed = Self::parse_price_json(&text, source, key)?;
         Ok(Some(parsed))
     }
 
+    fn fallback_sources(primary: &Source) -> &'static [Source] {
+        const KRAKEN_FALLBACKS: [Source; 2] = [Source::CoinGecko, Source::CoinDesk];
+        const COINGECKO_FALLBACKS: [Source; 2] = [Source::Kraken, Source::CoinDesk];
+        const YADIO_FALLBACKS: [Source; 2] = [Source::CoinGecko, Source::YadioConvert];
+        const COINGECKO_ONLY_FALLBACKS: [Source; 1] = [Source::CoinGecko];
+
+        match primary {
+            Source::Kraken => &KRAKEN_FALLBACKS,
+            Source::CoinGecko => &COINGECKO_FALLBACKS,
+            Source::Yadio => &YADIO_FALLBACKS,
+            Source::Exir => &COINGECKO_ONLY_FALLBACKS,
+            Source::YadioConvert
+            | Source::Coinpaprika
+            | Source::Bitstamp
+            | Source::Coinbase
+            | Source::BNR
+            | Source::CoinDesk => &COINGECKO_ONLY_FALLBACKS,
+        }
+    }
+
+    async fn resolve_price_with_fallback(
+        self: Arc<Self>,
+        unit: &FiatUnit,
+    ) -> Result<(String, Source), RatesError> {
+        for source in std::iter::once(unit.source)
+            .chain(Self::fallback_sources(&unit.source).iter().copied())
+        {
+            match self
+                .clone()
+                .fetch_price_for_source(&source, &unit.end_point_key)
+                .await
+            {
+                Ok(Some(price_str)) => return Ok((price_str, source)),
+                Ok(None) => {
+                    log::debug!(
+                        "No price from source={} for key={}",
+                        source,
+                        unit.end_point_key
+                    );
+                }
+                Err(e) => {
+                    log::warn!(
+                        "Price fetch failed from source={} for key={}: {}",
+                        source,
+                        unit.end_point_key,
+                        e
+                    );
+                }
+            }
+        }
+
+        Err(RatesError::MarketDataFetchFailed)
+    }
+
+    #[cfg(test)]
+    async fn resolve_price_with_fallback_with_fetcher<F, Fut>(
+        unit: &FiatUnit,
+        mut fetcher: F,
+    ) -> Result<(String, Source), RatesError>
+    where
+        F: FnMut(&Source, &str) -> Fut,
+        Fut: std::future::Future<Output = Result<Option<String>, RatesError>>,
+    {
+        for source in std::iter::once(unit.source)
+            .chain(Self::fallback_sources(&unit.source).iter().copied())
+        {
+            match fetcher(&source, &unit.end_point_key).await {
+                Ok(Some(price_str)) => return Ok((price_str, source)),
+                Ok(None) => {}
+                Err(_) => {}
+            }
+        }
+
+        Err(RatesError::MarketDataFetchFailed)
+    }
+
     async fn fetch_market_data_internal(
         self: Arc<Self>,
         currency: &str,
@@ -274,21 +354,22 @@ impl MarketAPI {
             None => return Err(RatesError::UnsupportedCurrency),
         };
 
-        if let Some(price_str) = self.fetch_price(&unit).await? {
-            if let Ok(rate) = price_str.parse::<f64>() {
-                let data = MarketData {
-                    price: format!("{} {:.0}", unit.symbol, rate),
-                    rate: rate,
-                    source: unit.source.to_string(),
-                };
-                log::debug!("Market data fetched in {:?}", start.elapsed());
-                return Ok(data);
-            } else {
-                return Err(RatesError::PriceParseFailed(price_str));
-            }
+        let (price_str, used_source) = self
+            .clone()
+            .resolve_price_with_fallback(&unit)
+            .await?;
+
+        if let Ok(rate) = price_str.parse::<f64>() {
+            let data = MarketData {
+                price: format!("{} {:.0}", unit.symbol, rate),
+                rate: rate,
+                source: used_source.to_string(),
+            };
+            log::debug!("Market data fetched in {:?}", start.elapsed());
+            return Ok(data);
         }
 
-        Err(RatesError::MarketDataFetchFailed)
+        Err(RatesError::PriceParseFailed(price_str))
     }
 }
 
@@ -328,6 +409,99 @@ impl MarketAPI {
     }
 }
 
+#[tokio::test]
+async fn test_fallback_primary_success() -> Result<(), RatesError> {
+    let unit = FiatUnit {
+        end_point_key: "USD".to_string(),
+        source: Source::Kraken,
+        symbol: "$".to_string(),
+    };
+
+    let attempts = std::sync::Arc::new(std::sync::Mutex::new(Vec::<Source>::new()));
+    let attempts_closure = attempts.clone();
+
+    let (price, used_source) = MarketAPI::resolve_price_with_fallback_with_fetcher(&unit, move |source, _key| {
+        let attempts = attempts_closure.clone();
+        let source = source.clone();
+        async move {
+            attempts.lock().unwrap().push(source.clone());
+            if source == Source::Kraken {
+                Ok(Some("60000.0".to_string()))
+            } else {
+                Ok(None)
+            }
+        }
+    })
+    .await?;
+
+    assert_eq!(price, "60000.0");
+    assert_eq!(used_source, Source::Kraken);
+    assert_eq!(attempts.lock().unwrap().as_slice(), &[Source::Kraken]);
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_fallback_primary_fail_then_success() -> Result<(), RatesError> {
+    let unit = FiatUnit {
+        end_point_key: "USD".to_string(),
+        source: Source::Kraken,
+        symbol: "$".to_string(),
+    };
+
+    let attempts = std::sync::Arc::new(std::sync::Mutex::new(Vec::<Source>::new()));
+    let attempts_closure = attempts.clone();
+
+    let (price, used_source) = MarketAPI::resolve_price_with_fallback_with_fetcher(&unit, move |source, _key| {
+        let attempts = attempts_closure.clone();
+        let source = source.clone();
+        async move {
+            attempts.lock().unwrap().push(source.clone());
+            match source {
+                Source::Kraken => Err(RatesError::HttpRequest("kraken down".to_string())),
+                Source::CoinGecko => Ok(Some("61000.0".to_string())),
+                _ => Ok(None),
+            }
+        }
+    })
+    .await?;
+
+    assert_eq!(price, "61000.0");
+    assert_eq!(used_source, Source::CoinGecko);
+    assert_eq!(
+        attempts.lock().unwrap().as_slice(),
+        &[Source::Kraken, Source::CoinGecko]
+    );
+    Ok(())
+}
+
+#[tokio::test]
+async fn test_fallback_all_fail() {
+    let unit = FiatUnit {
+        end_point_key: "USD".to_string(),
+        source: Source::Kraken,
+        symbol: "$".to_string(),
+    };
+
+    let attempts = std::sync::Arc::new(std::sync::Mutex::new(Vec::<Source>::new()));
+    let attempts_closure = attempts.clone();
+
+    let result = MarketAPI::resolve_price_with_fallback_with_fetcher(&unit, move |source, _key| {
+        let attempts = attempts_closure.clone();
+        let source = source.clone();
+        async move {
+            attempts.lock().unwrap().push(source);
+            Ok(None)
+        }
+    })
+    .await;
+
+    assert!(matches!(result, Err(RatesError::MarketDataFetchFailed)));
+    assert_eq!(
+        attempts.lock().unwrap().as_slice(),
+        &[Source::Kraken, Source::CoinGecko, Source::CoinDesk]
+    );
+}
+
 #[tokio::test]
 async fn test_market_data_fetch_eur() -> Result<(), RatesError> {
     let api = MarketAPI::new()?;