Implement a minimal BTC/USD price feed feature

Author: zahorodnyi

crates/cli-client/src/cli/positions.rs

@@ -9,6 +9,7 @@ use crate::config::Config;
 use crate::error::Error;
 use crate::metadata::ContractMetadata;
 
+use crate::price_fetcher::{CoingeckoPriceFetcher, PriceFetcherError, fetch_btc_usd_price};
 use coin_store::{Store, UtxoEntry, UtxoFilter, UtxoQueryResult, UtxoStore};
 use contracts::option_offer::{OPTION_OFFER_SOURCE, OptionOfferArguments, get_option_offer_address};
 use contracts::options::{OPTION_SOURCE, OptionsArguments, get_options_address};
@@ -19,13 +20,32 @@ use simplicityhl::elements::Address;
 type ContractInfoResult = Result<Option<(Vec<u8>, Vec<u8>, String)>, coin_store::StoreError>;
 
 impl Cli {
+    #[allow(clippy::too_many_lines)]
     pub(crate) async fn run_positions(&self, config: Config) -> Result<(), Error> {
         let wallet = self.get_wallet(&config).await?;
 
         println!("Your Positions:");
         println!("===============");
         println!();
 
+        let fetcher = CoingeckoPriceFetcher::new();
+        let btc_result = tokio::task::spawn_blocking(move || fetch_btc_usd_price(&fetcher))
+            .await
+            .unwrap_or_else(|e| Err(PriceFetcherError::Internal(e.to_string())));
+
+        let btc_price = match btc_result {
+            Ok(price) => format!("{price:.2}$"),
+            Err(PriceFetcherError::RateLimit) => "Rate limit exceeded".to_string(),
+            Err(e) => {
+                eprintln!("Fetcher error: {e}");
+                "Price fetcher service unavailable".to_string()
+            }
+        };
+
+        println!("Current btc price: {btc_price}");
+        println!("-----------------------------");
+        println!();
+
         let user_script_pubkey = wallet.signer().p2pk_address(config.address_params())?.script_pubkey();
 
         let options_filter = UtxoFilter::new().source(OPTION_SOURCE);

crates/cli-client/src/error.rs

@@ -55,4 +55,7 @@ pub enum Error {
 
     #[error("Taproot pubkey generation error: {0}")]
     TaprootPubkeyGen(#[from] contracts::error::TaprootPubkeyGenError),
+
+    #[error("Price feed error: {0}")]
+    PriceFeed(#[from] crate::price_fetcher::PriceFetcherError),
 }

crates/cli-client/src/main.rs

@@ -7,6 +7,7 @@ mod explorer;
 mod fee;
 mod logging;
 mod metadata;
+mod price_fetcher;
 mod signing;
 mod sync;
 mod wallet;

crates/cli-client/src/price_fetcher.rs

@@ -0,0 +1,67 @@
+use serde::Deserialize;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum PriceFetcherError {
+    #[error("Request error: {0}")]
+    Request(#[from] minreq::Error),
+    #[error("Rate limit exceeded (429)")]
+    RateLimit,
+    #[error("Response status error: {0}")]
+    Status(i32),
+    #[error("Parse error: {0}")]
+    Parse(String),
+    #[error("Internal runtime error: {0}")]
+    Internal(String),
+}
+
+#[derive(Deserialize)]
+struct BitcoinResponse {
+    bitcoin: BitcoinPrice,
+}
+
+#[derive(Deserialize)]
+struct BitcoinPrice {
+    usd: f64,
+}
+
+pub trait PriceFetcher {
+    fn fetch_price(&self) -> Result<f64, PriceFetcherError>;
+}
+
+pub struct CoingeckoPriceFetcher;
+
+impl CoingeckoPriceFetcher {
+    const URL: &'static str = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd&precision=8";
+    const TIMEOUT_SECS: u64 = 5;
+
+    #[must_use]
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl PriceFetcher for CoingeckoPriceFetcher {
+    fn fetch_price(&self) -> Result<f64, PriceFetcherError> {
+        let resp = minreq::get(Self::URL)
+            .with_header("User-Agent", "simplicity-dex/1.0")
+            .with_timeout(Self::TIMEOUT_SECS)
+            .send()
+            .map_err(PriceFetcherError::from)?;
+
+        let price = match resp.status_code {
+            200 => resp
+                .json::<BitcoinResponse>()
+                .map(|data| data.bitcoin.usd)
+                .map_err(|e| PriceFetcherError::Parse(e.to_string()))?,
+            429 => return Err(PriceFetcherError::RateLimit),
+            status => return Err(PriceFetcherError::Status(status)),
+        };
+
+        Ok(price)
+    }
+}
+
+pub fn fetch_btc_usd_price<T: PriceFetcher>(fetcher: &T) -> Result<f64, PriceFetcherError> {
+    fetcher.fetch_price()
+}