fix(#65): add LoadingState to stores and standardize async error handling

- supportStore: add loadingState field, wrap createTicket with
  loading/success/failure states
- fraudStore: add loadingState field, wrap refreshFraudSignals with
  loading/success/failure states
- settingsStore: add loadingState field, wrap updateExchangeRates with
  loading/success/failure states; keep isLoading for back-compat
- invoiceStore: import LoadingState type ready for store actions

Author: rindicomfort

src/store/fraudStore.ts

@@ -1,6 +1,7 @@
 import { create } from 'zustand';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { LoadingState, idle, loading, success, failure } from '../types/loadingState';
 import {
   FraudAction,
   FraudAnalytics,
@@ -244,6 +245,7 @@ interface FraudState {
   analytics: FraudAnalytics;
   loading: boolean;
   error: string | null;
+  loadingState: LoadingState;
   refreshFraudSignals: () => void;
   assessRisk: (subscriberId: string) => FraudRiskScore[];
   flagSubscription: (subscriptionId: string) => void;
@@ -301,26 +303,34 @@ export const useFraudStore = create<FraudState>()(
       reviewQueue: hydrateReviewQueue(reviewSeeds),
       analytics: computeAnalytics(subscriptionSeeds, reviewSeeds),
       loading: false,
+      loadingState: idle(),
       error: null,
 
       refreshFraudSignals: () => {
-        const { subscriptions, reviewQueue, merchants } = get();
-        set({
-          analytics: computeAnalytics(subscriptions, reviewQueue),
-          assessments: hydrateAssessments(subscriptions),
-          merchants: merchants.map((merchant) => ({
-            ...merchant,
-            averageRisk: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk,
-            blockedSubscriptions: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).blockedSubscriptions,
-            activeSubscriptions: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).totalSubscriptions,
-            status:
-              buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk >= 60
-                ? 'high-risk'
-                : buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk >= 35
-                  ? 'watch'
-                  : 'healthy',
-          })),
-        });
+        set({ loading: true, loadingState: loading() });
+        try {
+          const { subscriptions, reviewQueue, merchants } = get();
+          set({
+            analytics: computeAnalytics(subscriptions, reviewQueue),
+            assessments: hydrateAssessments(subscriptions),
+            merchants: merchants.map((merchant) => ({
+              ...merchant,
+              averageRisk: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk,
+              blockedSubscriptions: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).blockedSubscriptions,
+              activeSubscriptions: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).totalSubscriptions,
+              status:
+                buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk >= 60
+                  ? 'high-risk'
+                  : buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk >= 35
+                    ? 'watch'
+                    : 'healthy',
+            })),
+            loading: false,
+            loadingState: success(),
+          });
+        } catch (e) {
+          set({ loading: false, loadingState: failure(e as Error) });
+        }
       },
 
       assessRisk: (subscriberId: string) => {

src/store/invoiceStore.ts

@@ -23,6 +23,7 @@ import {
 import { buildInvoice, calculateInvoiceTotals } from '../utils/invoice';
 import { CACHE_CONSTANTS } from '../utils/constants/values';
 import { errorHandler, AppError } from '../services/errorHandler';
+import { LoadingState, idle, loading, success, failure } from '../types/loadingState';
 import { presentLocalNotification } from '../services/notificationService';
 
 const STORAGE_KEY = 'subtrackr-invoices';

src/store/settingsStore.ts

@@ -2,13 +2,15 @@ import { create } from 'zustand';
 import { persist, createJSONStorage } from 'zustand/middleware';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { currencyService, ExchangeRates } from '../services/currencyService';
+import { LoadingState, idle, loading, success, failure } from '../types/loadingState';
 
 interface SettingsState {
   preferredCurrency: string;
   notificationsEnabled: boolean;
   exchangeRates: ExchangeRates | null;
   isLoading: boolean;
-  
+  loadingState: LoadingState;
+
   // Actions
   setPreferredCurrency: (currency: string) => void;
   setNotificationsEnabled: (enabled: boolean) => void;
@@ -23,20 +25,23 @@ export const useSettingsStore = create<SettingsState>()(
       notificationsEnabled: true,
       exchangeRates: null,
       isLoading: false,
+      loadingState: idle(),
 
       setPreferredCurrency: (currency) => {
         set({ preferredCurrency: currency });
-        // Optionally update rates immediately if base changed, 
-        // but here we keep USD as base for rates to simplify conversion
         void get().updateExchangeRates();
       },
 
       setNotificationsEnabled: (enabled) => set({ notificationsEnabled: enabled }),
 
       updateExchangeRates: async () => {
-        set({ isLoading: true });
-        const rates = await currencyService.fetchRates('USD');
-        set({ exchangeRates: rates, isLoading: false });
+        set({ isLoading: true, loadingState: loading() });
+        try {
+          const rates = await currencyService.fetchRates('USD');
+          set({ exchangeRates: rates, isLoading: false, loadingState: success() });
+        } catch (e) {
+          set({ isLoading: false, loadingState: failure(e as Error, ['Check your internet connection', 'Try again later']) });
+        }
       },
 
       initializeSettings: async () => {

src/store/supportStore.ts

@@ -11,10 +11,12 @@ import {
   TicketingIntegrationConfig,
   TicketStatus,
 } from '../types/support';
+import { LoadingState, idle, loading, success, failure } from '../types/loadingState';
 
 interface SupportState {
   tickets: SupportTicket[];
   integration: TicketingIntegrationConfig;
+  loadingState: LoadingState;
   createTicket: (event: SubscriptionSupportEvent) => SupportTicket;
   assignTicket: (ticketId: string, assignee: string) => void;
   updateTicketStatus: (ticketId: string, status: TicketStatus) => void;
@@ -32,14 +34,21 @@ const mapTicket = (
 export const useSupportStore = create<SupportState>((set, get) => ({
   tickets: [],
   integration: { provider: 'internal', enabled: true, defaultAssignee: 'support-team' },
+  loadingState: idle(),
 
   createTicket: (event) => {
-    const relatedTicketIds = get()
-      .tickets.filter((ticket) => ticket.subscriptionId === event.subscriptionId && ticket.status !== 'closed')
-      .map((ticket) => ticket.id);
-    const ticket = createTicketFromEvent(event, relatedTicketIds);
-    set((state) => ({ tickets: [...state.tickets, ticket] }));
-    return ticket;
+    set({ loadingState: loading() });
+    try {
+      const relatedTicketIds = get()
+        .tickets.filter((ticket) => ticket.subscriptionId === event.subscriptionId && ticket.status !== 'closed')
+        .map((ticket) => ticket.id);
+      const ticket = createTicketFromEvent(event, relatedTicketIds);
+      set((state) => ({ tickets: [...state.tickets, ticket], loadingState: success() }));
+      return ticket;
+    } catch (e) {
+      set({ loadingState: failure(e as Error) });
+      throw e;
+    }
   },
 
   assignTicket: (ticketId, assignee) =>