currencyrate: round to the third digit and adding source argument to `currencyrate` command

diff --git a/plugins/currencyrate-plugin/src/main.rs b/plugins/currencyrate-plugin/src/main.rs
index e03d0bbd..8057dfd0 100644
--- a/plugins/currencyrate-plugin/src/main.rs
+++ b/plugins/currencyrate-plugin/src/main.rs
@@ -17,6 +17,10 @@ mod oracle;
 const DEFAULT_PROXY_PORT: u16 = 9050;
 const MSAT_PER_BTC: f64 = 1e11;
 
+fn round_to_3dp(price: f64) -> f64 {
+    format!("{:.3}", price).parse::<f64>().unwrap_or(price)
+}
+
 #[derive(Debug, Clone)]
 pub struct SourceResult {
     pub name: String,
@@ -115,6 +119,12 @@ median from currencyrates results",
 async fn currencyconvert(plugin: Plugin<PluginState>, args: Value) -> Result<Value, anyhow::Error> {
     let (amount, currency) = match args {
         Value::Array(values) => {
+            if values.len() > 2 {
+                return Err(anyhow!(
+                    "Too many arguments: Expected 2 arguments, got {}",
+                    values.len()
+                ));
+            }
             let amount = values
                 .first()
                 .ok_or_else(|| anyhow!("Missing amount"))?
@@ -129,6 +139,12 @@ async fn currencyconvert(plugin: Plugin<PluginState>, args: Value) -> Result<Val
             (amount, currency.to_uppercase())
         }
         Value::Object(map) => {
+            if map.len() > 2 {
+                return Err(anyhow!(
+                    "Too many arguments: Expected 2 arguments, got {}",
+                    map.len()
+                ));
+            }
             let amount = map
                 .get("amount")
                 .ok_or_else(|| anyhow!("Missing amount"))?
@@ -157,24 +173,46 @@ async fn currencyconvert(plugin: Plugin<PluginState>, args: Value) -> Result<Val
 }
 
 async fn currencyrate(plugin: Plugin<PluginState>, args: Value) -> Result<Value, anyhow::Error> {
-    let currency = match args {
+    let (currency, source) = match args {
         Value::Array(values) => {
+            if values.len() > 2 {
+                return Err(anyhow!(
+                    "Too many arguments: Expected at most 2 arguments, got {}",
+                    values.len()
+                ));
+            }
             let currency = values
                 .first()
                 .ok_or_else(|| anyhow!("Missing currency"))?
                 .as_str()
                 .ok_or_else(|| anyhow!("currency must be a string"))?
-                .to_owned();
-            currency.to_uppercase()
+                .to_uppercase();
+            let source = values.get(1).and_then(|v| {
+                v.as_str()
+                    .map(str::to_owned)
+                    .or_else(|| v.as_number().map(std::string::ToString::to_string))
+            });
+            (currency, source)
         }
         Value::Object(map) => {
+            if map.len() > 2 {
+                return Err(anyhow!(
+                    "Too many arguments: Expected at most 2 arguments, got {}",
+                    map.len()
+                ));
+            }
             let currency = map
                 .get("currency")
                 .ok_or_else(|| anyhow!("Missing currency"))?
                 .as_str()
                 .ok_or_else(|| anyhow!("currency must be a string"))?
-                .to_owned();
-            currency.to_uppercase()
+                .to_uppercase();
+            let source = map.get("source").and_then(|v| {
+                v.as_str()
+                    .map(str::to_owned)
+                    .or_else(|| v.as_number().map(std::string::ToString::to_string))
+            });
+            (currency, source)
         }
         _ => return Err(anyhow!("Arguments must be an array or dictionary")),
     };
@@ -182,12 +220,18 @@ async fn currencyrate(plugin: Plugin<PluginState>, args: Value) -> Result<Value,
     let oracle = plugin.state().oracle.lock().await;
     oracle.currency_requested(&currency).await;
 
-    match oracle.get_median_rate(&currency).await {
-        Ok(result) => Ok(json!({
-            "rate": result,
-        })),
-        Err(e) => Err(anyhow!("Error converting currency: {e}")),
-    }
+    let rate = match source {
+        Some(source_name) => oracle
+            .get_source_rate(&currency, &source_name)
+            .await
+            .map_err(|e| anyhow!("Error getting rate from source: {e}"))?,
+        None => oracle
+            .get_median_rate(&currency)
+            .await
+            .map_err(|e| anyhow!("Error getting median rate: {e}"))?,
+    };
+
+    Ok(json!({ "rate": round_to_3dp(rate) }))
 }
 
 async fn listcurrencyrates(
@@ -196,6 +240,12 @@ async fn listcurrencyrates(
 ) -> Result<Value, anyhow::Error> {
     let currency = match args {
         Value::Array(values) => {
+            if values.len() > 1 {
+                return Err(anyhow!(
+                    "Too many arguments: Expected 1 argument, got {}",
+                    values.len()
+                ));
+            }
             let currency = values
                 .first()
                 .ok_or_else(|| anyhow!("Missing currency"))?
@@ -205,6 +255,12 @@ async fn listcurrencyrates(
             currency.to_uppercase()
         }
         Value::Object(map) => {
+            if map.len() > 1 {
+                return Err(anyhow!(
+                    "Too many arguments: Expected 1 argument, got {}",
+                    map.len()
+                ));
+            }
             let currency = map
                 .get("currency")
                 .ok_or_else(|| anyhow!("Missing currency"))?
@@ -226,7 +282,7 @@ async fn listcurrencyrates(
                 .map(|source_result| {
                     json!({
                         "source": source_result.name,
-                        "amount": source_result.price,
+                        "amount": round_to_3dp(source_result.price),
                     })
                 })
                 .collect::<Vec<_>>();
diff --git a/plugins/currencyrate-plugin/src/oracle.rs b/plugins/currencyrate-plugin/src/oracle.rs
index 7145c4ff..5e53a140 100644
--- a/plugins/currencyrate-plugin/src/oracle.rs
+++ b/plugins/currencyrate-plugin/src/oracle.rs
@@ -523,6 +523,48 @@ impl BtcPriceOracle {
             }
         });
     }
+
+    pub async fn get_source_rate(
+        &self,
+        currency: &str,
+        source_name: &str,
+    ) -> Result<f64, anyhow::Error> {
+        self.refresh_currency(currency).await?;
+
+        let inner = self.inner.lock().await;
+
+        // Give a helpful error if the source name is unknown entirely
+        if !inner.sources.contains_key(source_name) {
+            let available = inner
+                .sources
+                .keys()
+                .cloned()
+                .collect::<Vec<_>>()
+                .join(", ");
+            return Err(anyhow!(
+                "Unknown source `{source_name}`. Available sources: {available}"
+            ));
+        }
+
+        let currency_cache = inner
+            .currencies
+            .get(currency)
+            .ok_or_else(|| anyhow!("No rates available for `{currency}`"))?;
+
+        let price_cache = currency_cache
+            .prices
+            .get(source_name)
+            .ok_or_else(|| anyhow!(
+                "Source `{source_name}` has no data for `{currency}`. \
+                The source may not support this currency or is currently backing off."
+            ))?;
+
+        if price_cache.timestamp + SERVE_TTL <= Instant::now() {
+            return Err(anyhow!("Cached rate from `{source_name}` is expired"));
+        }
+
+        Ok(price_cache.price)
+    }
 }
 
 fn get_median(source_results: Vec<SourceResult>) -> f64 {