feat(auth): poll trezor connection status and sign out when disconnected

packages/komodo_defi_local_auth/.gitignore

@@ -31,6 +31,7 @@ migrate_working_dir/
 /build/
 pubspec.lock
 build/
+web/
 
 # Web related
 lib/generated_plugin_registrant.dart

packages/komodo_defi_local_auth/lib/src/trezor/_trezor_index.dart

@@ -4,6 +4,8 @@
 library _trezor;
 
 export 'trezor_auth_service.dart';
+export 'trezor_connection_monitor.dart';
+export 'trezor_connection_status.dart';
 export 'trezor_exception.dart';
 export 'trezor_initialization_state.dart';
 export 'trezor_repository.dart';

packages/komodo_defi_local_auth/lib/src/trezor/trezor_auth_service.dart

@@ -16,15 +16,27 @@ import 'package:logging/logging.dart';
 /// handling passphrase requirements and ignoring PIN prompts. All other
 /// [IAuthService] methods are delegated to the composed auth service.
 class TrezorAuthService implements IAuthService {
-  TrezorAuthService(this._authService, this._trezor);
+  TrezorAuthService(
+    this._authService,
+    this._trezor, {
+    TrezorConnectionMonitor? connectionMonitor,
+    FlutterSecureStorage? secureStorage,
+    String Function(int length)? passwordGenerator,
+  }) : _connectionMonitor =
+           connectionMonitor ?? TrezorConnectionMonitor(_trezor),
+       _secureStorage = secureStorage ?? const FlutterSecureStorage(),
+       _generatePassword =
+           passwordGenerator ?? SecurityUtils.generatePasswordSecure;
 
   static const String trezorWalletName = 'My Trezor';
   static const String _passwordKey = 'trezor_wallet_password';
   static final _log = Logger('TrezorAuthService');
 
   final IAuthService _authService;
   final TrezorRepository _trezor;
-  final FlutterSecureStorage _secureStorage = const FlutterSecureStorage();
+  final FlutterSecureStorage _secureStorage;
+  final TrezorConnectionMonitor _connectionMonitor;
+  final String Function(int length) _generatePassword;
 
   Future<void> provideTrezorPin(int taskId, String pin) =>
       _trezor.providePin(taskId, pin);
@@ -100,10 +112,16 @@ class TrezorAuthService implements IAuthService {
   Stream<KdfUser?> get authStateChanges => _authService.authStateChanges;
 
   @override
-  Future<void> dispose() => _authService.dispose();
+  Future<void> dispose() async {
+    _connectionMonitor.dispose();
+    await _authService.dispose();
+  }
 
   @override
-  Future<void> signOut() => _authService.signOut();
+  Future<void> signOut() async {
+    await _stopConnectionMonitoring();
+    await _authService.signOut();
+  }
 
   @override
   Future<void> deleteWallet({
@@ -126,7 +144,11 @@ class TrezorAuthService implements IAuthService {
     }
 
     try {
-      return await _initializeTrezorWithPassphrase(passphrase: password);
+      final user = await _initializeTrezorWithPassphrase(passphrase: password);
+
+      _startConnectionMonitoring();
+
+      return user;
     } catch (e) {
       await _signOutCurrentTrezorUser();
 
@@ -154,7 +176,11 @@ class TrezorAuthService implements IAuthService {
     }
 
     try {
-      return await _initializeTrezorWithPassphrase(passphrase: password);
+      final user = await _initializeTrezorWithPassphrase(passphrase: password);
+
+      _startConnectionMonitoring();
+
+      return user;
     } catch (e) {
       await _signOutCurrentTrezorUser();
 
@@ -180,7 +206,7 @@ class TrezorAuthService implements IAuthService {
 
     if (existing != null) return existing;
 
-    final newPassword = SecurityUtils.generatePasswordSecure(16);
+    final newPassword = _generatePassword(16);
     await _secureStorage.write(key: _passwordKey, value: newPassword);
     return newPassword;
   }
@@ -189,11 +215,34 @@ class TrezorAuthService implements IAuthService {
   Future<void> clearTrezorPassword() =>
       _secureStorage.delete(key: _passwordKey);
 
+  /// Start monitoring Trezor connection status after successful authentication.
+  /// This will automatically sign out if the device becomes disconnected.
+  void _startConnectionMonitoring({String? devicePubkey}) {
+    _connectionMonitor.startMonitoring(
+      devicePubkey: devicePubkey,
+      onConnectionLost: () async {
+        _log.warning('Trezor connection lost, signing out user');
+        await _signOutCurrentTrezorUser();
+      },
+      onStatusChanged: (status) {
+        _log.fine('Trezor connection status: ${status.value}');
+      },
+    );
+  }
+
+  /// Stop monitoring Trezor connection status.
+  Future<void> _stopConnectionMonitoring() async {
+    if (_connectionMonitor.isMonitoring) {
+      await _connectionMonitor.stopMonitoring();
+    }
+  }
+
   /// Signs out the current user if they are using the Trezor wallet
   Future<void> _signOutCurrentTrezorUser() async {
     final current = await _authService.getActiveUser();
     if (current?.walletId.name == trezorWalletName) {
       _log.warning("Signing out current '${current?.walletId.name}' user");
+      await _stopConnectionMonitoring();
       try {
         await _authService.signOut();
       } catch (_) {
@@ -286,6 +335,7 @@ class TrezorAuthService implements IAuthService {
         if (trezorState.status == AuthenticationStatus.completed) {
           final user = await _authService.getActiveUser();
           if (user != null) {
+            _startConnectionMonitoring();
             yield AuthenticationState.completed(user);
           } else {
             yield AuthenticationState.error(

packages/komodo_defi_local_auth/lib/src/trezor/trezor_connection_monitor.dart

@@ -0,0 +1,120 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:komodo_defi_local_auth/src/trezor/trezor_connection_status.dart';
+import 'package:komodo_defi_local_auth/src/trezor/trezor_repository.dart';
+import 'package:logging/logging.dart';
+
+/// Service responsible for monitoring Trezor device connection status
+/// and providing callbacks for connection state changes.
+class TrezorConnectionMonitor {
+  TrezorConnectionMonitor(this._trezorRepository);
+
+  static final _log = Logger('TrezorConnectionMonitor');
+
+  final TrezorRepository _trezorRepository;
+  StreamSubscription<TrezorConnectionStatus>? _connectionSubscription;
+  TrezorConnectionStatus? _lastStatus;
+
+  /// Start monitoring the Trezor connection status.
+  ///
+  /// [onConnectionLost] will be called when the device becomes disconnected
+  /// or unreachable.
+  /// [onConnectionRestored] will be called when the device becomes connected
+  /// after being disconnected/unreachable.
+  /// [onStatusChanged] will be called for any status change.
+  /// [maxDuration] sets the maximum time to monitor before timing out. If null,
+  /// monitoring continues indefinitely until stopped or disconnected.
+  void startMonitoring({
+    String? devicePubkey,
+    Duration pollInterval = const Duration(seconds: 1),
+    Duration? maxDuration,
+    VoidCallback? onConnectionLost,
+    VoidCallback? onConnectionRestored,
+    void Function(TrezorConnectionStatus)? onStatusChanged,
+  }) {
+    _log.info('Starting Trezor connection monitoring');
+
+    // Stop any existing monitoring safely before starting a new one.
+    final previousSubscription = _connectionSubscription;
+    if (previousSubscription != null) {
+      _log.info('Stopping previous Trezor connection monitoring');
+      _connectionSubscription = null;
+      _lastStatus = null;
+      unawaited(previousSubscription.cancel());
+    }
+
+    _connectionSubscription = _trezorRepository
+        .watchConnectionStatus(
+          devicePubkey: devicePubkey,
+          pollInterval: pollInterval,
+          maxDuration: maxDuration,
+        )
+        .listen(
+          (status) {
+            _log.fine('Connection status changed: ${status.value}');
+
+            final previousStatus = _lastStatus;
+            _lastStatus = status;
+
+            onStatusChanged?.call(status);
+
+            if (status.isUnavailable &&
+                (previousStatus?.isAvailable ?? false)) {
+              _log.warning('Trezor connection lost: ${status.value}');
+              onConnectionLost?.call();
+            }
+
+            if (status.isAvailable &&
+                (previousStatus?.isUnavailable ?? false)) {
+              _log.info('Trezor connection restored');
+              onConnectionRestored?.call();
+            }
+          },
+          onError: (Object error, StackTrace stackTrace) {
+            _log.severe(
+              'Error monitoring Trezor connection: $error',
+              error,
+              stackTrace,
+            );
+            // Only call onConnectionLost if this is a real connection error, not a disposal
+            if (_connectionSubscription != null) {
+              onConnectionLost?.call();
+            }
+          },
+          onDone: () {
+            _log.info('Trezor connection monitoring stopped');
+            // Underlying stream ended; mark as not monitoring while keeping
+            // the last known status for inspection.
+            _connectionSubscription = null;
+          },
+        );
+  }
+
+  /// Stop monitoring the Trezor connection status.
+  Future<void> stopMonitoring() async {
+    if (_connectionSubscription != null) {
+      _log.info('Stopping Trezor connection monitoring');
+      await _connectionSubscription?.cancel();
+      _connectionSubscription = null;
+      _lastStatus = null;
+    }
+  }
+
+  /// Get the last known connection status.
+  TrezorConnectionStatus? get lastKnownStatus => _lastStatus;
+
+  /// Check if monitoring is currently active.
+  bool get isMonitoring => _connectionSubscription != null;
+
+  /// Dispose of the monitor and clean up resources.
+  void dispose() {
+    // Make monitoring appear stopped synchronously.
+    final previousSubscription = _connectionSubscription;
+    _connectionSubscription = null;
+    _lastStatus = null;
+    if (previousSubscription != null) {
+      unawaited(previousSubscription.cancel());
+    }
+  }
+}

packages/komodo_defi_local_auth/lib/src/trezor/trezor_connection_status.dart

@@ -0,0 +1,65 @@
+/// Enum representing Trezor device connection status
+enum TrezorConnectionStatus {
+  /// Device is connected and ready for operations
+  connected,
+
+  /// Device is disconnected
+  disconnected,
+
+  /// Device is busy with another operation
+  busy,
+
+  /// Device is unreachable (possibly hardware issue or driver problem)
+  unreachable,
+
+  /// Unknown status (for unrecognized status strings)
+  unknown;
+
+  /// Parse a string status from the API response into enum
+  static TrezorConnectionStatus fromString(String status) {
+    switch (status.toLowerCase()) {
+      case 'connected':
+        return TrezorConnectionStatus.connected;
+      case 'disconnected':
+        return TrezorConnectionStatus.disconnected;
+      case 'busy':
+        return TrezorConnectionStatus.busy;
+      case 'unreachable':
+        return TrezorConnectionStatus.unreachable;
+      default:
+        return TrezorConnectionStatus.unknown;
+    }
+  }
+
+  /// Human-readable label for display purposes
+  String get value {
+    switch (this) {
+      case TrezorConnectionStatus.connected:
+        return 'Connected';
+      case TrezorConnectionStatus.disconnected:
+        return 'Disconnected';
+      case TrezorConnectionStatus.busy:
+        return 'Busy';
+      case TrezorConnectionStatus.unreachable:
+        return 'Unreachable';
+      case TrezorConnectionStatus.unknown:
+        return 'Unknown';
+    }
+  }
+
+  /// Lowercase identifier used by the API
+  String get apiValue => name; // matches fromString expectations
+
+  /// Check if the status indicates the device is available for operations
+  bool get isAvailable => this == TrezorConnectionStatus.connected;
+
+  /// Check if the status indicates the device is not available
+  bool get isUnavailable =>
+      this == TrezorConnectionStatus.disconnected ||
+      this == TrezorConnectionStatus.unreachable ||
+      this == TrezorConnectionStatus.busy;
+
+  /// Check if the device should continue being monitored
+  bool get shouldContinueMonitoring =>
+      this != TrezorConnectionStatus.disconnected;
+}

packages/komodo_defi_local_auth/lib/src/trezor/trezor_initialization_state.dart

@@ -1,6 +1,7 @@
 import 'package:freezed_annotation/freezed_annotation.dart';
 import 'package:komodo_defi_local_auth/komodo_defi_local_auth.dart';
 import 'package:komodo_defi_rpc_methods/komodo_defi_rpc_methods.dart';
+import 'package:komodo_defi_types/komodo_defi_types.dart';
 
 part 'trezor_initialization_state.freezed.dart';