{/* Balance */}
- {(balance !== undefined ||
- nwcConnection.balance !== undefined) && (
+ {balance !== undefined && (
Balance:
@@ -243,7 +217,7 @@ export default function UserMenu() {
{state.walletBalancesBlurred
? "✦✦✦✦✦✦"
- : formatBalance(balance ?? nwcConnection.balance)}
+ : formatBalance(balance)}
{state.walletBalancesBlurred ? (
@@ -263,30 +237,14 @@ export default function UserMenu() {
)}
- {/* Wallet Name */}
-
- Wallet:
-
-
-
{/* Connection Status */}
Status:
-
-
-
- {wallet ? "Connected" : "Disconnected"}
-
-
+
{/* Lightning Address */}
@@ -402,25 +360,15 @@ export default function UserMenu() {
>
- {balance !== undefined ||
- nwcConnection.balance !== undefined ? (
+ {balance !== undefined && (
{state.walletBalancesBlurred
? "✦✦✦✦"
- : formatBalance(balance ?? nwcConnection.balance)}
+ : formatBalance(balance)}
- ) : null}
-
-
-
-
- {getWalletName()}
-
+ )}
+
) : (
;
* }
*
- * return
Balance: {balance ? Math.floor(balance / 1000) : 0} sats
;
+ * // walletMethods combines support$ with cached info for reliability
+ * if (walletMethods.includes('pay_invoice')) {
+ * return
payInvoice("lnbc...")} />;
+ * }
+ *
+ * return Balance: {formatSats(balance)}
;
* }
* ```
*/
-import { useEffect, useState } from "react";
+import { useEffect, useMemo, useRef } from "react";
import { use$ } from "applesauce-react/hooks";
import { useGrimoire } from "@/core/state";
+import type { WalletSupport } from "applesauce-wallet-connect/helpers";
import {
- getWallet,
+ wallet$,
restoreWallet,
- clearWallet as clearWalletService,
+ clearWallet,
refreshBalance as refreshBalanceService,
+ reconnect as reconnectService,
balance$,
+ connectionStatus$,
+ lastError$,
+ transactionsState$,
+ loadTransactions as loadTransactionsService,
+ loadMoreTransactions as loadMoreTransactionsService,
+ retryLoadTransactions as retryLoadTransactionsService,
} from "@/services/nwc";
-import type { WalletConnect } from "applesauce-wallet-connect";
export function useWallet() {
const { state } = useGrimoire();
const nwcConnection = state.nwcConnection;
- const [wallet, setWallet] = useState(getWallet());
+ const restoreAttemptedRef = useRef(false);
- // Subscribe to balance updates from observable (fully reactive!)
+ // All state derived from observables
+ const wallet = use$(wallet$);
const balance = use$(balance$);
+ const connectionStatus = use$(connectionStatus$);
+ const lastError = use$(lastError$);
+ const transactionsState = use$(transactionsState$);
- // Initialize wallet on mount if connection exists but no wallet instance
+ // Wallet support from library's support$ observable (cached by library for 60s)
+ const support: WalletSupport | null | undefined = use$(
+ () => wallet?.support$,
+ [wallet],
+ );
+
+ // Wallet methods - combines reactive support$ with cached info fallback
+ // The support$ waits for kind 13194 events which some wallets don't publish
+ const walletMethods = useMemo(() => {
+ return support?.methods ?? state.nwcConnection?.info?.methods ?? [];
+ }, [support?.methods, state.nwcConnection?.info?.methods]);
+
+ // Restore wallet on mount if connection exists
+ // Note: Not awaited intentionally - wallet is available synchronously from wallet$
+ // before validation completes. Any async errors are handled within restoreWallet.
useEffect(() => {
- if (nwcConnection && !wallet) {
- console.log("[useWallet] Restoring wallet from saved connection");
- const restoredWallet = restoreWallet(nwcConnection);
- setWallet(restoredWallet);
-
- // Fetch initial balance
- refreshBalanceService();
+ if (nwcConnection && !wallet && !restoreAttemptedRef.current) {
+ restoreAttemptedRef.current = true;
+ restoreWallet(nwcConnection);
}
}, [nwcConnection, wallet]);
- // Update local wallet ref when connection changes
+ // Reset restore flag when connection is cleared
useEffect(() => {
- const currentWallet = getWallet();
- if (currentWallet !== wallet) {
- setWallet(currentWallet);
+ if (!nwcConnection) {
+ restoreAttemptedRef.current = false;
}
- }, [nwcConnection, wallet]);
+ }, [nwcConnection]);
+
+ // Derived state
+ const isConnected = connectionStatus !== "disconnected";
+
+ // ============================================================================
+ // Wallet operations
+ // ============================================================================
- /**
- * Pay a BOLT11 invoice
- * Balance will auto-update via notification subscription
- */
async function payInvoice(invoice: string, amount?: number) {
if (!wallet) throw new Error("No wallet connected");
-
const result = await wallet.payInvoice(invoice, amount);
-
- // Balance will update automatically via notifications
- // But we can also refresh immediately for instant feedback
await refreshBalanceService();
-
return result;
}
- /**
- * Generate a new invoice
- */
async function makeInvoice(
amount: number,
options?: {
@@ -88,40 +106,20 @@ export function useWallet() {
},
) {
if (!wallet) throw new Error("No wallet connected");
-
return await wallet.makeInvoice(amount, options);
}
- /**
- * Get wallet info (capabilities, alias, etc.)
- */
async function getInfo() {
if (!wallet) throw new Error("No wallet connected");
-
return await wallet.getInfo();
}
- /**
- * Get current balance
- */
async function getBalance() {
if (!wallet) throw new Error("No wallet connected");
-
const result = await wallet.getBalance();
return result.balance;
}
- /**
- * Manually refresh the balance
- */
- async function refreshBalance() {
- return await refreshBalanceService();
- }
-
- /**
- * List recent transactions
- * @param options - Pagination and filter options
- */
async function listTransactions(options?: {
from?: number;
until?: number;
@@ -131,69 +129,69 @@ export function useWallet() {
type?: "incoming" | "outgoing";
}) {
if (!wallet) throw new Error("No wallet connected");
-
return await wallet.listTransactions(options);
}
- /**
- * Look up an invoice by payment hash
- * @param paymentHash - The payment hash to look up
- */
async function lookupInvoice(paymentHash: string) {
if (!wallet) throw new Error("No wallet connected");
-
return await wallet.lookupInvoice(paymentHash);
}
- /**
- * Pay to a node pubkey directly (keysend)
- * @param pubkey - The node pubkey to pay
- * @param amount - Amount in millisats
- * @param preimage - Optional preimage (hex string)
- */
async function payKeysend(pubkey: string, amount: number, preimage?: string) {
if (!wallet) throw new Error("No wallet connected");
-
const result = await wallet.payKeysend(pubkey, amount, preimage);
-
- // Refresh balance after payment
await refreshBalanceService();
-
return result;
}
- /**
- * Disconnect the wallet
- */
function disconnect() {
- clearWalletService();
- setWallet(null);
+ clearWallet();
+ }
+
+ async function reconnect() {
+ await reconnectService();
+ }
+
+ async function refreshBalance() {
+ return await refreshBalanceService();
+ }
+
+ async function loadTransactions() {
+ await loadTransactionsService();
+ }
+
+ async function loadMoreTransactions() {
+ await loadMoreTransactionsService();
+ }
+
+ async function retryLoadTransactions() {
+ await retryLoadTransactionsService();
}
return {
- /** The wallet instance (null if not connected) */
+ // State (all derived from observables)
wallet,
- /** Current balance in millisats (auto-updates via observable!) */
balance,
- /** Whether a wallet is connected */
- isConnected: !!wallet,
- /** Pay a BOLT11 invoice */
+ isConnected,
+ connectionStatus,
+ lastError,
+ support,
+ walletMethods,
+ transactionsState,
+
+ // Operations
payInvoice,
- /** Generate a new invoice */
makeInvoice,
- /** Get wallet information */
getInfo,
- /** Get current balance */
getBalance,
- /** Manually refresh balance */
refreshBalance,
- /** List recent transactions */
listTransactions,
- /** Look up an invoice by payment hash */
lookupInvoice,
- /** Pay to a node pubkey directly (keysend) */
payKeysend,
- /** Disconnect wallet */
disconnect,
+ reconnect,
+ loadTransactions,
+ loadMoreTransactions,
+ retryLoadTransactions,
};
}
diff --git a/src/services/nwc.ts b/src/services/nwc.ts
index 8c40ba0..386a552 100644
--- a/src/services/nwc.ts
+++ b/src/services/nwc.ts
@@ -4,33 +4,65 @@
* Provides a singleton WalletConnect instance for the application using
* applesauce-wallet-connect for NIP-47 Lightning wallet integration.
*
- * Features:
- * - Maintains persistent wallet connection across app lifetime
- * - Subscribes to NIP-47 notifications (kind 23197) for balance updates
- * - Fully reactive using RxJS observables (no polling!)
- * - Components use use$() to reactively subscribe to balance changes
+ * Architecture:
+ * - All state is exposed via BehaviorSubject observables
+ * - Components subscribe via use$() for automatic updates
+ * - Notification subscription handles balance updates reactively
+ * - Automatic retry with exponential backoff on failures
*/
import { WalletConnect } from "applesauce-wallet-connect";
import type { NWCConnection } from "@/types/app";
+import {
+ type TransactionsState,
+ INITIAL_TRANSACTIONS_STATE,
+} from "@/types/wallet";
import pool from "./relay-pool";
-import { BehaviorSubject, Subscription } from "rxjs";
+import { BehaviorSubject, Subscription, firstValueFrom, timeout } from "rxjs";
-// Set the pool for wallet connect to use
+// Configure the pool for wallet connect
WalletConnect.pool = pool;
-let walletInstance: WalletConnect | null = null;
+// Internal state
let notificationSubscription: Subscription | null = null;
+let notificationRetryTimeout: ReturnType | null = null;
/**
- * Observable for wallet balance updates
- * Components can subscribe to this for real-time balance changes using use$()
+ * Connection status for the NWC wallet
*/
+export type NWCConnectionStatus =
+ | "disconnected"
+ | "connecting"
+ | "connected"
+ | "error";
+
+// ============================================================================
+// Observables - All state is exposed reactively
+// ============================================================================
+
+/** The current wallet instance (null if not connected) */
+export const wallet$ = new BehaviorSubject(null);
+
+/** Connection status */
+export const connectionStatus$ = new BehaviorSubject(
+ "disconnected",
+);
+
+/** Last connection error (null if no error) */
+export const lastError$ = new BehaviorSubject(null);
+
+/** Current balance in millisats */
export const balance$ = new BehaviorSubject(undefined);
-/**
- * Helper to convert hex string to Uint8Array
- */
+/** Transaction list state (lazy loaded) */
+export const transactionsState$ = new BehaviorSubject(
+ INITIAL_TRANSACTIONS_STATE,
+);
+
+// ============================================================================
+// Internal helpers
+// ============================================================================
+
function hexToBytes(hex: string): Uint8Array {
const bytes = new Uint8Array(hex.length / 2);
for (let i = 0; i < hex.length; i += 2) {
@@ -40,111 +72,383 @@ function hexToBytes(hex: string): Uint8Array {
}
/**
- * Subscribe to wallet notifications (NIP-47 kind 23197)
- * This enables real-time balance updates when transactions occur
+ * Subscribe to wallet notifications with automatic retry on error.
+ * Notifications trigger balance refresh for real-time updates.
*/
function subscribeToNotifications(wallet: WalletConnect) {
- // Clean up existing subscription
- if (notificationSubscription) {
- notificationSubscription.unsubscribe();
+ // Clean up existing subscription and pending retry
+ notificationSubscription?.unsubscribe();
+ notificationSubscription = null;
+ if (notificationRetryTimeout) {
+ clearTimeout(notificationRetryTimeout);
+ notificationRetryTimeout = null;
}
- console.log("[NWC] Subscribing to wallet notifications");
+ let retryCount = 0;
+ const maxRetries = 5;
+ const baseDelay = 2000;
- // Subscribe to the wallet's notifications$ observable
- // This receives events like payment_received, payment_sent, etc.
- notificationSubscription = wallet.notifications$.subscribe({
- next: (notification) => {
- console.log("[NWC] Notification received:", notification);
+ function subscribe() {
+ notificationSubscription = wallet.notifications$.subscribe({
+ next: (notification) => {
+ console.log(
+ "[NWC] Notification received:",
+ notification.notification_type,
+ );
+ retryCount = 0;
- // When we get a notification, refresh the balance
- // The notification types include: payment_received, payment_sent, etc.
- wallet
- .getBalance()
- .then((result) => {
- const newBalance = result.balance;
- if (balance$.value !== newBalance) {
- balance$.next(newBalance);
- console.log("[NWC] Balance updated from notification:", newBalance);
- }
- })
- .catch((error) => {
- console.error(
- "[NWC] Failed to fetch balance after notification:",
- error,
+ // Recover from error state on successful notification
+ if (connectionStatus$.value === "error") {
+ connectionStatus$.next("connected");
+ lastError$.next(null);
+ }
+
+ // Refresh balance and transactions on any notification
+ refreshBalance();
+ refreshTransactions();
+ },
+ error: (error) => {
+ console.error("[NWC] Notification error:", error);
+
+ if (retryCount < maxRetries) {
+ const delay = baseDelay * Math.pow(2, retryCount);
+ retryCount++;
+ connectionStatus$.next("connecting");
+ notificationRetryTimeout = setTimeout(subscribe, delay);
+ } else {
+ connectionStatus$.next("error");
+ lastError$.next(
+ error instanceof Error
+ ? error
+ : new Error("Notification subscription failed"),
);
- });
- },
- error: (error) => {
- console.error("[NWC] Notification subscription error:", error);
- },
- });
+ }
+ },
+ complete: () => {
+ // Reconnect if subscription completes unexpectedly
+ if (wallet$.value && retryCount < maxRetries) {
+ const delay = baseDelay * Math.pow(2, retryCount);
+ retryCount++;
+ notificationRetryTimeout = setTimeout(subscribe, delay);
+ }
+ },
+ });
+ }
+
+ subscribe();
}
+// ============================================================================
+// Public API
+// ============================================================================
+
/**
- * Creates a new WalletConnect instance from a connection string
- * Automatically subscribes to notifications for balance updates
+ * Creates a new wallet connection from a NWC URI.
+ * Used when user connects a new wallet.
*/
export function createWalletFromURI(connectionString: string): WalletConnect {
- walletInstance = WalletConnect.fromConnectURI(connectionString);
- subscribeToNotifications(walletInstance);
- return walletInstance;
+ connectionStatus$.next("connecting");
+ lastError$.next(null);
+
+ const wallet = WalletConnect.fromConnectURI(connectionString);
+ wallet$.next(wallet);
+
+ subscribeToNotifications(wallet);
+ refreshBalance(); // Fetch initial balance
+
+ return wallet;
}
/**
- * Restores a wallet from saved connection data
- * Used on app startup to reconnect to a previously connected wallet
+ * Restores a wallet from saved connection data.
+ * Validates the connection before marking as connected.
*/
-export function restoreWallet(connection: NWCConnection): WalletConnect {
- walletInstance = new WalletConnect({
+export async function restoreWallet(
+ connection: NWCConnection,
+): Promise {
+ connectionStatus$.next("connecting");
+ lastError$.next(null);
+
+ const wallet = new WalletConnect({
service: connection.service,
relays: connection.relays,
secret: hexToBytes(connection.secret),
});
- // Set initial balance from cache
+ wallet$.next(wallet);
+
+ // Show cached balance immediately while validating
if (connection.balance !== undefined) {
balance$.next(connection.balance);
}
- subscribeToNotifications(walletInstance);
- return walletInstance;
+ // Validate connection by waiting for support info
+ try {
+ await firstValueFrom(
+ wallet.support$.pipe(
+ timeout({
+ first: 10000,
+ with: () => {
+ throw new Error("Connection timeout");
+ },
+ }),
+ ),
+ );
+ connectionStatus$.next("connected");
+ } catch (error) {
+ console.error("[NWC] Validation failed:", error);
+ connectionStatus$.next("error");
+ lastError$.next(
+ error instanceof Error ? error : new Error("Connection failed"),
+ );
+ // Continue anyway - notifications will retry
+ }
+
+ subscribeToNotifications(wallet);
+ refreshBalance();
+
+ return wallet;
}
/**
- * Gets the current wallet instance
- */
-export function getWallet(): WalletConnect | null {
- return walletInstance;
-}
-
-/**
- * Clears the current wallet instance and stops notifications
+ * Disconnects and clears the wallet.
*/
export function clearWallet(): void {
- if (notificationSubscription) {
- notificationSubscription.unsubscribe();
- notificationSubscription = null;
+ // Clean up subscription and pending retry
+ notificationSubscription?.unsubscribe();
+ notificationSubscription = null;
+ if (notificationRetryTimeout) {
+ clearTimeout(notificationRetryTimeout);
+ notificationRetryTimeout = null;
}
- walletInstance = null;
+
+ wallet$.next(null);
balance$.next(undefined);
+ connectionStatus$.next("disconnected");
+ lastError$.next(null);
+ resetTransactions();
}
/**
- * Manually refresh the balance from the wallet
- * Useful for initial load or manual refresh button
+ * Refreshes the balance from the wallet.
+ * Includes retry logic with exponential backoff for reliability.
+ *
+ * Note: If we're already connected and a balance fetch fails after retries,
+ * we don't set error state. This prevents UI flapping - the notification
+ * subscription is the primary health indicator. A transient balance fetch
+ * failure shouldn't mark an otherwise working connection as errored.
*/
export async function refreshBalance(): Promise {
- if (!walletInstance) return undefined;
+ const wallet = wallet$.value;
+ if (!wallet) return undefined;
+
+ const maxRetries = 3;
+ const baseDelay = 1000;
+
+ for (let attempt = 0; attempt < maxRetries; attempt++) {
+ try {
+ const result = await wallet.getBalance();
+ balance$.next(result.balance);
+
+ // Recover from error state on success
+ if (connectionStatus$.value === "error") {
+ connectionStatus$.next("connected");
+ lastError$.next(null);
+ }
+
+ return result.balance;
+ } catch (error) {
+ console.error(
+ `[NWC] Balance refresh failed (attempt ${attempt + 1}):`,
+ error,
+ );
+
+ if (attempt < maxRetries - 1) {
+ await new Promise((r) =>
+ setTimeout(r, baseDelay * Math.pow(2, attempt)),
+ );
+ } else if (connectionStatus$.value !== "connected") {
+ // Only set error state if not already connected (e.g., during initial validation)
+ connectionStatus$.next("error");
+ lastError$.next(
+ error instanceof Error ? error : new Error("Failed to get balance"),
+ );
+ }
+ }
+ }
+
+ return undefined;
+}
+
+/**
+ * Attempts to reconnect after an error.
+ */
+export async function reconnect(): Promise {
+ const wallet = wallet$.value;
+ if (!wallet) return;
+
+ connectionStatus$.next("connecting");
+ lastError$.next(null);
+
+ subscribeToNotifications(wallet);
+ await refreshBalance();
+}
+
+// ============================================================================
+// Transaction loading (lazy, paginated)
+// ============================================================================
+
+const TRANSACTIONS_PAGE_SIZE = 20;
+
+/**
+ * Loads the initial batch of transactions.
+ * Only loads if not already initialized (lazy loading).
+ */
+export async function loadTransactions(): Promise {
+ const wallet = wallet$.value;
+ if (!wallet) return;
+
+ const current = transactionsState$.value;
+
+ // Skip if already loading or initialized
+ if (current.loading || current.initialized) return;
+
+ transactionsState$.next({
+ ...current,
+ loading: true,
+ error: null,
+ });
try {
- const result = await walletInstance.getBalance();
- const newBalance = result.balance;
+ const result = await wallet.listTransactions({
+ limit: TRANSACTIONS_PAGE_SIZE,
+ });
- balance$.next(newBalance);
- return newBalance;
+ transactionsState$.next({
+ items: result.transactions,
+ loading: false,
+ loadingMore: false,
+ hasMore: result.transactions.length >= TRANSACTIONS_PAGE_SIZE,
+ error: null,
+ initialized: true,
+ });
} catch (error) {
- console.error("[NWC] Failed to refresh balance:", error);
- return undefined;
+ console.error("[NWC] Failed to load transactions:", error);
+ transactionsState$.next({
+ ...transactionsState$.value,
+ loading: false,
+ error:
+ error instanceof Error
+ ? error
+ : new Error("Failed to load transactions"),
+ initialized: true,
+ });
}
}
+
+/**
+ * Loads more transactions (pagination).
+ */
+export async function loadMoreTransactions(): Promise {
+ const wallet = wallet$.value;
+ if (!wallet) return;
+
+ const current = transactionsState$.value;
+
+ // Skip if already loading or no more to load
+ if (current.loading || current.loadingMore || !current.hasMore) return;
+
+ transactionsState$.next({
+ ...current,
+ loadingMore: true,
+ });
+
+ try {
+ // Get the oldest transaction timestamp for pagination
+ const oldestTx = current.items[current.items.length - 1];
+ const until = oldestTx?.created_at;
+
+ const result = await wallet.listTransactions({
+ limit: TRANSACTIONS_PAGE_SIZE,
+ until,
+ });
+
+ // Filter out any duplicates (in case of overlapping timestamps)
+ const existingHashes = new Set(current.items.map((tx) => tx.payment_hash));
+ const newTransactions = result.transactions.filter(
+ (tx) => !existingHashes.has(tx.payment_hash),
+ );
+
+ transactionsState$.next({
+ ...current,
+ items: [...current.items, ...newTransactions],
+ loadingMore: false,
+ hasMore: result.transactions.length >= TRANSACTIONS_PAGE_SIZE,
+ });
+ } catch (error) {
+ console.error("[NWC] Failed to load more transactions:", error);
+ transactionsState$.next({
+ ...current,
+ loadingMore: false,
+ error:
+ error instanceof Error
+ ? error
+ : new Error("Failed to load more transactions"),
+ });
+ }
+}
+
+/**
+ * Refreshes the transaction list (prepends new transactions).
+ * Called automatically on payment notifications.
+ */
+export async function refreshTransactions(): Promise {
+ const wallet = wallet$.value;
+ if (!wallet) return;
+
+ const current = transactionsState$.value;
+
+ // Only refresh if already initialized
+ if (!current.initialized) return;
+
+ try {
+ // Get the newest transaction timestamp
+ const newestTx = current.items[0];
+ const from = newestTx?.created_at ? newestTx.created_at + 1 : undefined;
+
+ const result = await wallet.listTransactions({
+ limit: TRANSACTIONS_PAGE_SIZE,
+ from,
+ });
+
+ // Filter out duplicates and prepend new transactions
+ const existingHashes = new Set(current.items.map((tx) => tx.payment_hash));
+ const newTransactions = result.transactions.filter(
+ (tx) => !existingHashes.has(tx.payment_hash),
+ );
+
+ if (newTransactions.length > 0) {
+ transactionsState$.next({
+ ...current,
+ items: [...newTransactions, ...current.items],
+ });
+ }
+ } catch (error) {
+ console.error("[NWC] Failed to refresh transactions:", error);
+ }
+}
+
+/**
+ * Resets transaction state (called on wallet clear).
+ */
+function resetTransactions(): void {
+ transactionsState$.next(INITIAL_TRANSACTIONS_STATE);
+}
+
+/**
+ * Force reload transactions (used for retry after error).
+ */
+export async function retryLoadTransactions(): Promise {
+ resetTransactions();
+ await loadTransactions();
+}
diff --git a/src/types/app.ts b/src/types/app.ts
index 5b114e5..ff449c8 100644
--- a/src/types/app.ts
+++ b/src/types/app.ts
@@ -100,6 +100,7 @@ export interface NWCConnection {
/** Optional wallet info */
info?: {
alias?: string;
+ network?: string;
methods?: string[];
notifications?: string[];
};
diff --git a/src/types/wallet.ts b/src/types/wallet.ts
new file mode 100644
index 0000000..78132fe
--- /dev/null
+++ b/src/types/wallet.ts
@@ -0,0 +1,51 @@
+/**
+ * Wallet-related type definitions for NWC (NIP-47)
+ */
+
+/**
+ * A Lightning/Bitcoin transaction from NWC list_transactions
+ */
+export interface Transaction {
+ type: "incoming" | "outgoing";
+ invoice?: string;
+ description?: string;
+ description_hash?: string;
+ preimage?: string;
+ payment_hash?: string;
+ amount: number;
+ fees_paid?: number;
+ created_at: number;
+ expires_at?: number;
+ settled_at?: number;
+ metadata?: Record;
+}
+
+/**
+ * State for the transactions observable
+ */
+export interface TransactionsState {
+ /** The list of transactions */
+ items: Transaction[];
+ /** Whether we're loading the initial batch */
+ loading: boolean;
+ /** Whether we're loading more (pagination) */
+ loadingMore: boolean;
+ /** Whether there are more transactions to load */
+ hasMore: boolean;
+ /** Error from last load attempt */
+ error: Error | null;
+ /** Whether initial load has been triggered */
+ initialized: boolean;
+}
+
+/**
+ * Initial state for transactions
+ */
+export const INITIAL_TRANSACTIONS_STATE: TransactionsState = {
+ items: [],
+ loading: false,
+ loadingMore: false,
+ hasMore: true,
+ error: null,
+ initialized: false,
+};