bool isValidRateEvent(NostrEvent event, String mostroPubkey) {
  // 1. Correct kind
  if (event.kind != 30078) return false;

  // 2. Has d:mostro-rates tag
  final dTag = event.tags?.firstWhere(
    (t) => t.isNotEmpty && t[0] == "d",
    orElse: () => [],
  );
  if (dTag == null || dTag.length < 2 || dTag[1] != "mostro-rates") return false;

  // 3. CRITICAL: signed by our connected Mostro instance
  if (event.pubkey != mostroPubkey) return false;

  return true;
}

// lib/data/models/exchange_rates.dart

class ExchangeRates {
  final Map<String, double> rates; // {"USD": 50000.0, "EUR": 45000.0, ...}
  final DateTime fetchedAt;
  final ExchangeRateSource source;

  const ExchangeRates({
    required this.rates,
    required this.fetchedAt,
    required this.source,
  });

  bool get isStale =>
      DateTime.now().difference(fetchedAt) > const Duration(minutes: 15);

  double? rateFor(String currency) => rates[currency.toUpperCase()];

  Map<String, dynamic> toJson() => {
    "rates": rates,
    "fetched_at": fetchedAt.millisecondsSinceEpoch,
    "source": source.name,
  };

  factory ExchangeRates.fromJson(Map<String, dynamic> json) => ExchangeRates(
    rates: Map<String, double>.from(json["rates"]),
    fetchedAt: DateTime.fromMillisecondsSinceEpoch(json["fetched_at"]),
    source: ExchangeRateSource.values.byName(json["source"]),
  );
}

enum ExchangeRateSource { nostr, http, cache }

// lib/data/repositories/exchange_rates_storage.dart

import "package:sembast/sembast.dart";
import "package:mostro_mobile/data/repositories/base_storage.dart";
import "package:mostro_mobile/data/models/exchange_rates.dart";

class ExchangeRatesStorage extends BaseStorage<ExchangeRates> {
  static const _singletonKey = "current";

  ExchangeRatesStorage({required Database db})
      : super(db, stringMapStoreFactory.store("exchange_rates"));

  @override
  Map<String, dynamic> toDbMap(ExchangeRates item) => item.toJson();

  @override
  ExchangeRates fromDbMap(String key, Map<String, dynamic> json) =>
      ExchangeRates.fromJson(json);

  /// Save current rates (singleton — always overwrites)
  Future<void> saveRates(ExchangeRates rates) =>
      putItem(_singletonKey, rates);

  /// Load last saved rates (null if never fetched)
  Future<ExchangeRates?> loadRates() => getItem(_singletonKey);
}

// Use the same relay list already configured for Mostro orders
final filter = NostrFilter(
  kinds: [30078],
  authors: [mostroInstance.pubkey], // ONLY from our Mostro
  additionalFilters: {"#d": ["mostro-rates"]},
);

// lib/features/exchange_rates/exchange_rates_provider.dart

@riverpod
Future<ExchangeRates> exchangeRates(ExchangeRatesRef ref) async {
  final mostroPubkey = ref.watch(mostroInstanceProvider)!.pubkey;
  final nostrService = ref.watch(nostrServiceProvider);
  final storage = ref.watch(exchangeRatesStorageProvider);

  // Try Nostr first (10s timeout)
  try {
    final rates = await nostrService
        .fetchLatestRates(mostroPubkey)
        .timeout(const Duration(seconds: 10));
    await storage.saveRates(rates);
    return rates;
  } catch (e) {
    logger.w("Nostr rates failed: $e");
  }

  // Fallback: Yadio HTTP API
  try {
    final rates = await YadioService.fetchRates();
    await storage.saveRates(rates);
    return rates;
  } catch (e) {
    logger.e("HTTP rates failed: $e");
  }

  // Last resort: Sembast cache
  final cached = await storage.loadRates();
  if (cached != null) return cached;

  throw ExchangeRatesFetchException("No rates available");
}

Future<ExchangeRates> fetchLatestRates(String mostroPubkey) async {
  final completer = Completer<ExchangeRates>();

  final sub = nostrPool.subscribe(
    [filter],
    onEvent: (event) {
      if (!isValidRateEvent(event, mostroPubkey)) return;

      try {
        final content = jsonDecode(event.content) as Map<String, dynamic>;
        final btcRates = content["BTC"] as Map<String, dynamic>;
        final rates = btcRates.map((k, v) => MapEntry(k, (v as num).toDouble()));
        completer.complete(ExchangeRates(
          rates: rates,
          fetchedAt: DateTime.now(),
          source: ExchangeRateSource.nostr,
        ));
      } catch (e) {
        logger.e("Failed to parse rate event content: $e");
        // Do NOT complete with error — keep waiting or fall back
      }
    },
  );

  return completer.future.whenComplete(() => sub.close());
}

// In initialization flow
final cached = await exchangeRatesStorage.loadRates();
if (cached != null) {
  // Show cached rates immediately; refresh in background
  ref.read(exchangeRatesProvider.notifier).setCached(cached);
}

final ratesAsync = ref.watch(exchangeRatesProvider);

ratesAsync.when(
  data: (rates) => Column(
    children: [
      if (rates.isStale)
        WarningBanner(
          message: "Exchange rates may be outdated",
        ),
      OrderForm(rates: rates),
    ],
  ),
  loading: () => const CircularProgressIndicator(),
  error: (e, _) => ErrorView(
    message: "Could not fetch exchange rates",
    onRetry: () => ref.refresh(exchangeRatesProvider),
  ),
);

test("rejects event from wrong pubkey", () { ... });
test("parses BTC rates from content correctly", () { ... });
test("falls back to HTTP when Nostr times out", () { ... });
test("loads Sembast cache when both Nostr and HTTP fail", () { ... });
test("isStale returns true after 15 minutes", () { ... });