refactor(spot): source prices directly from Elering LIVE

Drop the spot-hinta.fi middleman and read Nord Pool day-ahead straight
from the TSO-grade open source (Elering LIVE, keyless). Converts EUR/MWh
ex-VAT → c/kWh incl VAT (25.5%) and buckets by Europe/Helsinki (via
chrono-tz) so today/tomorrow line up with the local day regardless of
server timezone.

Author: eetu

backend/Cargo.lock

@@ -22,6 +22,7 @@ tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 rusqlite = { version = "0.40", features = ["bundled"] }
 chrono = { version = "0.4", features = ["serde"] }
+chrono-tz = "0.10"
 quick-xml = "0.40"
 sun = "0.3"
 hmac = "0.13.0"

backend/Cargo.toml

@@ -39,7 +39,7 @@ impl Settings {
             solis_station_id: String::new(),
             solis_base_url: "https://www.soliscloud.com:13333".into(),
             reserve_provider: "reserve".into(),
-            spot_base_url: "https://api.spot-hinta.fi".into(),
+            spot_base_url: "https://dashboard.elering.ee".into(),
         }
     }
 
@@ -74,7 +74,7 @@ impl Settings {
                 .unwrap_or_else(|_| "https://www.soliscloud.com:13333".into()),
             reserve_provider: env::var("RESERVE_PROVIDER").unwrap_or_else(|_| "reserve".into()),
             spot_base_url: env::var("SPOT_BASE_URL")
-                .unwrap_or_else(|_| "https://api.spot-hinta.fi".into()),
+                .unwrap_or_else(|_| "https://dashboard.elering.ee".into()),
         }
     }
 }

backend/src/settings.rs

@@ -1,34 +1,60 @@
 use std::collections::BTreeMap;
 
-use chrono::{DateTime, FixedOffset, NaiveDate, Timelike};
+use chrono::{DateTime, Datelike, Duration, NaiveDate, TimeZone, Timelike, Utc};
+use chrono_tz::{Europe::Helsinki, Tz};
 
-use super::models::{HourPrice, SpotEntry, SpotResponse};
+use super::models::{HourPrice, NpsEntry, NpsResponse, SpotResponse};
 
+/// Finnish electricity VAT (25.5%). Elering prices are ex-VAT; we display the
+/// consumer price like the price apps do.
+const VAT: f64 = 1.255;
+
+/// Fetch today + tomorrow Finnish prices straight from the TSO-grade open source
+/// (Elering LIVE, Nord Pool day-ahead). API: <https://dashboard.elering.ee/api>
 pub async fn fetch(
     client: &reqwest::Client,
     base_url: &str,
 ) -> Result<SpotResponse, reqwest::Error> {
-    let url = format!("{}/TodayAndDayForward", base_url.trim_end_matches('/'));
-    let entries: Vec<SpotEntry> = client
-        .get(&url)
+    // Window the query to [today 00:00, +2 days) in Helsinki time so the day
+    // split lines up with the local day, regardless of the server timezone.
+    let now = Utc::now().with_timezone(&Helsinki);
+    let start = Helsinki
+        .with_ymd_and_hms(now.year(), now.month(), now.day(), 0, 0, 0)
+        .single()
+        .unwrap_or(now);
+    let end = start + Duration::days(2);
+    let iso = |d: DateTime<Tz>| {
+        d.with_timezone(&Utc)
+            .format("%Y-%m-%dT%H:%M:%S.000Z")
+            .to_string()
+    };
+    let url = format!(
+        "{}/api/nps/price?start={}&end={}",
+        base_url.trim_end_matches('/'),
+        iso(start),
+        iso(end),
+    );
+
+    let resp: NpsResponse = client
+        .get(url)
         .send()
         .await?
         .error_for_status()?
         .json()
         .await?;
-    Ok(aggregate(entries))
+    Ok(aggregate(resp.data.fi))
 }
 
-/// Average the 15-min quarters into hourly bars and split into today/tomorrow
-/// (the two distinct local dates the upstream returns).
-fn aggregate(entries: Vec<SpotEntry>) -> SpotResponse {
+/// Average the 15-min entries into hourly bars (in Helsinki local time) and split
+/// into today/tomorrow; convert EUR/MWh ex-VAT → c/kWh incl. VAT.
+fn aggregate(entries: Vec<NpsEntry>) -> SpotResponse {
     // (local date, hour) -> (price sum, count, hour-start datetime)
-    let mut buckets: BTreeMap<(NaiveDate, u32), (f64, u32, DateTime<FixedOffset>)> =
-        BTreeMap::new();
+    let mut buckets: BTreeMap<(NaiveDate, u32), (f64, u32, DateTime<Tz>)> = BTreeMap::new();
     for e in &entries {
-        let Ok(dt) = DateTime::parse_from_rfc3339(&e.date_time) else {
+        let Some(utc) = Utc.timestamp_opt(e.timestamp, 0).single() else {
             continue;
         };
+        let dt = utc.with_timezone(&Helsinki);
         let hour_start = dt
             .with_minute(0)
             .and_then(|d| d.with_second(0))
@@ -37,7 +63,7 @@ fn aggregate(entries: Vec<SpotEntry>) -> SpotResponse {
         let slot = buckets
             .entry((dt.date_naive(), dt.hour()))
             .or_insert((0.0, 0, hour_start));
-        slot.0 += e.price_with_tax;
+        slot.0 += e.price;
         slot.1 += 1;
     }
 
@@ -53,7 +79,7 @@ fn aggregate(entries: Vec<SpotEntry>) -> SpotResponse {
             .filter(|((d, _), _)| *d == target)
             .map(|(_, (sum, count, hour_start))| HourPrice {
                 hour: hour_start.to_rfc3339(),
-                price: (sum / *count as f64) * 100.0, // €/kWh -> c/kWh
+                price: (sum / *count as f64) / 10.0 * VAT, // EUR/MWh ex-VAT -> c/kWh incl VAT
             })
             .collect()
     };

backend/src/spot/client.rs

@@ -1,5 +1,6 @@
-//! Finnish spot electricity prices — public, keyless upstream (spot-hinta.fi),
-//! fetched directly like the weather sources. 15-min data aggregated to hourly.
+//! Finnish spot electricity prices — fetched straight from the TSO-grade open
+//! source (Elering LIVE, the Estonian TSO's Nord Pool day-ahead feed), keyless,
+//! like the weather sources. EUR/MWh ex-VAT → c/kWh incl VAT, 15-min → hourly.
 pub mod client;
 pub mod handlers;
 pub mod models;

backend/src/spot/mod.rs

@@ -1,13 +1,24 @@
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
 
-/// Raw entry from spot-hinta.fi `/TodayAndDayForward` (15-min resolution).
+/// One entry from Elering LIVE `/api/nps/price` — EUR/MWh ex-VAT, Unix-UTC ts.
 #[derive(Debug, Deserialize)]
-pub struct SpotEntry {
-    #[serde(rename = "DateTime")]
-    pub date_time: String, // RFC3339 with local offset, e.g. 2026-06-14T00:15:00+03:00
-    #[serde(rename = "PriceWithTax", default)]
-    pub price_with_tax: f64, // €/kWh, incl. VAT
+pub struct NpsEntry {
+    pub timestamp: i64,
+    pub price: f64,
+}
+
+/// `data` object: one array per bidding zone; we read Finland (`fi`).
+#[derive(Debug, Default, Deserialize)]
+pub struct NpsData {
+    #[serde(default)]
+    pub fi: Vec<NpsEntry>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct NpsResponse {
+    #[serde(default)]
+    pub data: NpsData,
 }
 
 /// One hourly bar. `hour` is the local-time hour start (RFC3339); `price` is