feat: localization of core/bitbox

lib/core/bitbox/domain/errors/bitbox_errors.dart

@@ -1,4 +1,6 @@
 // lib/core/bitbox/domain/errors/bitbox_errors.dart
+import 'package:bb_mobile/core/utils/build_context_x.dart';
+import 'package:flutter/material.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 
 part 'bitbox_errors.freezed.dart';
@@ -23,21 +25,23 @@ sealed class BitBoxError with _$BitBoxError {
 
   const BitBoxError._();
 
-  String get message => when(
-    permissionDenied: () => 'USB permissions are required to connect to BitBox devices.',
-    noDevicesFound: () => 'No BitBox devices found. Make sure your device is powered on and connected via USB.',
-    multipleDevicesFound: () => 'Multiple BitBox devices found. Please ensure only one device is connected.',
-    deviceNotFound: () => 'BitBox device not found.',
-    connectionTypeNotInitialized: () => 'Connection type not initialized.',
-    noActiveConnection: () => 'No active connection to BitBox device.',
-    deviceMismatch: () => 'Device mismatch detected.',
-    invalidMagicBytes: () => 'Invalid PSBT format detected.',
-    deviceNotPaired: () => 'Device not paired. Please complete the pairing process first.',
-    handshakeFailed: () => 'Failed to establish secure connection. Please try again.',
-    operationTimeout: () => 'Operation timed out. Please try again.',
-    connectionFailed: () => 'Failed to connect to BitBox device. Please check your connection.',
-    invalidResponse: () => 'Invalid response from BitBox device. Please try again.',
-    operationCancelled: () => 'Operation was cancelled. Please try again.',
+  /// Returns the localized error message.
+  String toTranslated(BuildContext context) => when(
+    permissionDenied: () => context.loc.bitboxErrorPermissionDenied,
+    noDevicesFound: () => context.loc.bitboxErrorNoDevicesFound,
+    multipleDevicesFound: () => context.loc.bitboxErrorMultipleDevicesFound,
+    deviceNotFound: () => context.loc.bitboxErrorDeviceNotFound,
+    connectionTypeNotInitialized: () =>
+        context.loc.bitboxErrorConnectionTypeNotInitialized,
+    noActiveConnection: () => context.loc.bitboxErrorNoActiveConnection,
+    deviceMismatch: () => context.loc.bitboxErrorDeviceMismatch,
+    invalidMagicBytes: () => context.loc.bitboxErrorInvalidMagicBytes,
+    deviceNotPaired: () => context.loc.bitboxErrorDeviceNotPaired,
+    handshakeFailed: () => context.loc.bitboxErrorHandshakeFailed,
+    operationTimeout: () => context.loc.bitboxErrorOperationTimeout,
+    connectionFailed: () => context.loc.bitboxErrorConnectionFailed,
+    invalidResponse: () => context.loc.bitboxErrorInvalidResponse,
+    operationCancelled: () => context.loc.bitboxErrorOperationCancelled,
     operationFailed: (msg) => msg,
   );
 }

lib/features/bitbox/bitbox_action.dart

@@ -1,4 +1,5 @@
-
+import 'package:bb_mobile/core/utils/build_context_x.dart';
+import 'package:flutter/material.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 
 part 'bitbox_action.freezed.dart';
@@ -13,63 +14,64 @@ sealed class BitBoxAction with _$BitBoxAction {
 
   const BitBoxAction._();
 
-  String get title {
+  String toTitle(BuildContext context) {
     return when(
-      unlockDevice: () => 'Unlock BitBox Device',
-      pairDevice: () => 'Pair BitBox Device',
-      importWallet: () => 'Import BitBox Wallet',
-      signTransaction: () => 'Sign Transaction',
-      verifyAddress: () => 'Verify Address on BitBox',
+      unlockDevice: () => context.loc.bitboxActionUnlockDeviceTitle,
+      pairDevice: () => context.loc.bitboxActionPairDeviceTitle,
+      importWallet: () => context.loc.bitboxActionImportWalletTitle,
+      signTransaction: () => context.loc.bitboxActionSignTransactionTitle,
+      verifyAddress: () => context.loc.bitboxActionVerifyAddressTitle,
     );
   }
 
-  String get buttonText {
+  String toButtonText(BuildContext context) {
     return when(
-      unlockDevice: () => 'Unlock Device',
-      pairDevice: () => 'Start Pairing',
-      importWallet: () => 'Start Import',
-      signTransaction: () => 'Start Signing',
-      verifyAddress: () => 'Verify Address',
+      unlockDevice: () => context.loc.bitboxActionUnlockDeviceButton,
+      pairDevice: () => context.loc.bitboxActionPairDeviceButton,
+      importWallet: () => context.loc.bitboxActionImportWalletButton,
+      signTransaction: () => context.loc.bitboxActionSignTransactionButton,
+      verifyAddress: () => context.loc.bitboxActionVerifyAddressButton,
     );
   }
 
-  String get processingText {
+  String toProcessingText(BuildContext context) {
     return when(
-      unlockDevice: () => 'Unlocking Device',
-      pairDevice: () => 'Pairing Device',
-      importWallet: () => 'Importing Wallet',
-      signTransaction: () => 'Signing Transaction',
-      verifyAddress: () => 'Showing address on BitBox...',
+      unlockDevice: () => context.loc.bitboxActionUnlockDeviceProcessing,
+      pairDevice: () => context.loc.bitboxActionPairDeviceProcessing,
+      importWallet: () => context.loc.bitboxActionImportWalletProcessing,
+      signTransaction: () => context.loc.bitboxActionSignTransactionProcessing,
+      verifyAddress: () => context.loc.bitboxActionVerifyAddressProcessing,
     );
   }
 
-  String get successText {
+  String toSuccessText(BuildContext context) {
     return when(
-      unlockDevice: () => 'Device Unlocked Successfully',
-      pairDevice: () => 'Device Paired Successfully',
-      importWallet: () => 'Wallet Imported Successfully',
-      signTransaction: () => 'Transaction Signed Successfully',
-      verifyAddress: () => 'Address Verified Successfully',
+      unlockDevice: () => context.loc.bitboxActionUnlockDeviceSuccess,
+      pairDevice: () => context.loc.bitboxActionPairDeviceSuccess,
+      importWallet: () => context.loc.bitboxActionImportWalletSuccess,
+      signTransaction: () => context.loc.bitboxActionSignTransactionSuccess,
+      verifyAddress: () => context.loc.bitboxActionVerifyAddressSuccess,
     );
   }
 
-  String get successSubText {
+  String toSuccessSubText(BuildContext context) {
     return when(
-      unlockDevice: () => 'Your BitBox device is now unlocked and ready to use.',
-      pairDevice: () => 'Your BitBox device is now paired and ready to use.',
-      importWallet: () => 'Your BitBox wallet has been imported successfully.',
-      signTransaction: () => 'Your transaction has been signed successfully.',
-      verifyAddress: () => 'The address has been verified on your BitBox device.',
+      unlockDevice: () => context.loc.bitboxActionUnlockDeviceSuccessSubtext,
+      pairDevice: () => context.loc.bitboxActionPairDeviceSuccessSubtext,
+      importWallet: () => context.loc.bitboxActionImportWalletSuccessSubtext,
+      signTransaction: () => context.loc.bitboxActionSignTransactionSuccessSubtext,
+      verifyAddress: () => context.loc.bitboxActionVerifyAddressSuccessSubtext,
     );
   }
 
-  String get processingSubText {
+  String toProcessingSubText(BuildContext context) {
     return when(
-      unlockDevice: () => 'Please enter your password on the BitBox device...',
-      pairDevice: () => 'Please verify the pairing code on your BitBox device...',
-      importWallet: () => 'Setting up your watch-only wallet...',
-      signTransaction: () => 'Please confirm the transaction on your BitBox device...',
-      verifyAddress: () => 'Please confirm the address on your BitBox device.',
+      unlockDevice: () => context.loc.bitboxActionUnlockDeviceProcessingSubtext,
+      pairDevice: () => context.loc.bitboxActionPairDeviceProcessingSubtext,
+      importWallet: () => context.loc.bitboxActionImportWalletProcessingSubtext,
+      signTransaction: () =>
+          context.loc.bitboxActionSignTransactionProcessingSubtext,
+      verifyAddress: () => context.loc.bitboxActionVerifyAddressProcessingSubtext,
     );
   }
 }

lib/features/bitbox/presentation/cubit/bitbox_operation_cubit.dart

@@ -46,7 +46,7 @@ class BitBoxOperationCubit extends Cubit<BitBoxOperationState> {
     emit(
       state.copyWith(
         status: BitBoxOperationStatus.waitingForPassword,
-        errorMessage: null,
+        error: null,
       ),
     );
   }
@@ -55,7 +55,7 @@ class BitBoxOperationCubit extends Cubit<BitBoxOperationState> {
     emit(
       state.copyWith(
         status: BitBoxOperationStatus.processing,
-        errorMessage: null,
+        error: null,
       ),
     );
   }
@@ -79,7 +79,7 @@ class BitBoxOperationCubit extends Cubit<BitBoxOperationState> {
         emit(
           state.copyWith(
             status: BitBoxOperationStatus.scanning,
-            errorMessage: null,
+            error: null,
           ),
         );
 
@@ -108,12 +108,11 @@ class BitBoxOperationCubit extends Cubit<BitBoxOperationState> {
         throw BitBoxError.operationFailed(message: e.toString());
       }
     } on BitBoxError catch (e) {
-      final message = e.message;
-      log.warning('BitBox operation failed: $message');
+      log.warning('BitBox operation failed: $e');
       emit(
         state.copyWith(
           status: BitBoxOperationStatus.error,
-          errorMessage: message,
+          error: e,
         ),
       );
       rethrow;
@@ -124,15 +123,15 @@ class BitBoxOperationCubit extends Cubit<BitBoxOperationState> {
         emit(
           state.copyWith(
             status: BitBoxOperationStatus.error,
-            errorMessage: interpretedMessage,
+            error: BitBoxError.operationFailed(message: interpretedMessage),
           ),
         );
       } else {
         log.warning('BitBox operation failed: $e');
         emit(
           state.copyWith(
             status: BitBoxOperationStatus.error,
-            errorMessage: e.toString(),
+            error: BitBoxError.operationFailed(message: e.toString()),
           ),
         );
       }

lib/features/bitbox/presentation/cubit/bitbox_operation_state.dart

@@ -1,4 +1,5 @@
 import 'package:bb_mobile/core/bitbox/domain/entities/bitbox_device_entity.dart';
+import 'package:bb_mobile/core/bitbox/domain/errors/bitbox_errors.dart';
 import 'package:freezed_annotation/freezed_annotation.dart';
 
 part 'bitbox_operation_state.freezed.dart';
@@ -20,7 +21,7 @@ sealed class BitBoxOperationState with _$BitBoxOperationState {
   const factory BitBoxOperationState({
     @Default(BitBoxOperationStatus.initial) BitBoxOperationStatus status,
     BitBoxDeviceEntity? connectedDevice,
-    String? errorMessage,
+    BitBoxError? error,
     dynamic result,
   }) = _BitBoxOperationState;