diff --git a/.gitignore b/.gitignore
index 9482d8f94b..a36cb95a17 100644
--- a/.gitignore
+++ b/.gitignore
@@ -228,3 +228,6 @@ flatpak-build/
 **/linux/flutter/generated_plugin_registrant.cc
 **/linux/flutter/generated_plugin_registrant.h
 **/linux/flutter/generated_plugins.cmake
+
+
+wallet_fuzzer_data/
\ No newline at end of file
diff --git a/cw_bitcoin/lib/bitcoin_wallet_keys.dart b/cw_bitcoin/lib/bitcoin_wallet_keys.dart
index 4ed0da49cc..1e732489b1 100644
--- a/cw_bitcoin/lib/bitcoin_wallet_keys.dart
+++ b/cw_bitcoin/lib/bitcoin_wallet_keys.dart
@@ -6,6 +6,11 @@ class BitcoinWalletKeys {
   final String publicKey;
   final String xpub;
 
+  @override
+  String toString() {
+    return 'BitcoinWalletKeys(wif: $wif, privateKey: $privateKey, publicKey: $publicKey, xpub: $xpub)';
+  }
+
   Map<String, String> toJson() => {
     'wif': wif,
     'privateKey': privateKey,
diff --git a/cw_core/lib/monero_wallet_keys.dart b/cw_core/lib/monero_wallet_keys.dart
index 4ead3d743a..4324f82707 100644
--- a/cw_core/lib/monero_wallet_keys.dart
+++ b/cw_core/lib/monero_wallet_keys.dart
@@ -13,4 +13,9 @@ class MoneroWalletKeys {
   final String publicSpendKey;
   final String privateSpendKey;
   final String passphrase;
+
+  @override
+  String toString() {
+    return 'MoneroWalletKeys(primaryAddress: $primaryAddress, publicViewKey: $publicViewKey, privateViewKey: $privateViewKey, publicSpendKey: $publicSpendKey, privateSpendKey: $privateSpendKey, passphrase: $passphrase)';
+  }
 }
\ No newline at end of file
diff --git a/cw_nano/lib/nano_wallet_keys.dart b/cw_nano/lib/nano_wallet_keys.dart
index 80a845e644..af72ed6c69 100644
--- a/cw_nano/lib/nano_wallet_keys.dart
+++ b/cw_nano/lib/nano_wallet_keys.dart
@@ -2,4 +2,9 @@ class NanoWalletKeys {
   const NanoWalletKeys({required this.seedKey});
 
   final String seedKey;
+
+  @override
+  String toString() {
+    return 'NanoWalletKeys(seedKey: $seedKey)';
+  }
 }
diff --git a/cw_zano/lib/model/zano_wallet_keys.dart b/cw_zano/lib/model/zano_wallet_keys.dart
index 5a224633bb..40fd1d645d 100644
--- a/cw_zano/lib/model/zano_wallet_keys.dart
+++ b/cw_zano/lib/model/zano_wallet_keys.dart
@@ -9,4 +9,9 @@ class ZanoWalletKeys {
   final String privateViewKey;
   final String publicSpendKey;
   final String privateSpendKey;
+
+  @override
+  String toString() {
+    return 'ZanoWalletKeys(publicViewKey: $publicViewKey, privateViewKey: $privateViewKey, publicSpendKey: $publicSpendKey, privateSpendKey: $privateSpendKey)';
+  }
 }
\ No newline at end of file
diff --git a/lib/di.dart b/lib/di.dart
index f913478c53..591bdf966c 100644
--- a/lib/di.dart
+++ b/lib/di.dart
@@ -37,6 +37,10 @@ import 'package:cake_wallet/src/screens/dev/moneroc_call_profiler.dart';
 import 'package:cake_wallet/src/screens/dev/network_requests.dart';
 import 'package:cake_wallet/src/screens/dev/secure_preferences_page.dart';
 import 'package:cake_wallet/src/screens/dev/shared_preferences_page.dart';
+import 'package:cake_wallet/src/screens/dev/file_explorer.dart';
+import 'package:cake_wallet/src/screens/dev/monero_background_sync.dart';
+import 'package:cake_wallet/src/screens/dev/moneroc_call_profiler.dart';
+import 'package:cake_wallet/src/screens/dev/wallet_fuzzer.dart';
 import 'package:cake_wallet/src/screens/integrations/deuro/savings_page.dart';
 import 'package:cake_wallet/src/screens/settings/background_sync_page.dart';
 import 'package:cake_wallet/src/screens/start_tor/start_tor_page.dart';
@@ -1513,6 +1517,10 @@ Future<void> setup({
   
   getIt.registerFactory(() => DevBackgroundSyncLogsPage(getIt.get<BackgroundSyncLogsViewModel>()));
   
+  getIt.registerFactory(() => FileExplorerPage());
+
+  getIt.registerFactory(() => WalletFuzzerPage());
+
   getIt.registerFactory(() => SocketHealthLogsViewModel());
   getIt.registerFactory(() => DevSocketHealthLogsPage(getIt.get<SocketHealthLogsViewModel>()));
   
diff --git a/lib/main.dart b/lib/main.dart
index f37c69705b..9dc1fc68c0 100644
--- a/lib/main.dart
+++ b/lib/main.dart
@@ -34,6 +34,7 @@ import 'package:cake_wallet/utils/exception_handler.dart';
 import 'package:cake_wallet/utils/feature_flag.dart';
 import 'package:cake_wallet/view_model/link_view_model.dart';
 import 'package:cake_wallet/utils/responsive_layout_util.dart';
+import 'package:cake_wallet/view_model/dev/file_explorer.dart';
 import 'package:cw_core/address_info.dart';
 import 'package:cw_core/cake_hive.dart';
 import 'package:cw_core/hive_type_ids.dart';
@@ -72,6 +73,9 @@ Future<void> runAppWithZone({Key? topLevelKey}) async {
 
   await runZonedGuarded(() async {
     WidgetsFlutterBinding.ensureInitialized();
+    if (FeatureFlag.hasDevOptions) {
+      await checkAndStartFileMonitoring();
+    }
     FlutterError.onError = ExceptionHandler.onError;
 
     /// A callback that is invoked when an unhandled error occurs in the root
@@ -221,6 +225,11 @@ Future<void> initializeAppConfigs({bool loadWallet = true}) async {
   final trades = await CakeHive.openBox<Trade>(Trade.boxName, encryptionKey: tradesBoxKey);
   final orders = await CakeHive.openBox<Order>(Order.boxName, encryptionKey: ordersBoxKey);
   final walletInfoSource = await CakeHive.openBox<WalletInfo>(WalletInfo.boxName);
+  if (walletInfoSource.length == 0) {
+    printV("WalletInfo corrupted: length == 0");
+  } else {
+    printV("WalletInfo normal: ${walletInfoSource.length}");
+  }
   final templates = await CakeHive.openBox<Template>(Template.boxName);
   final exchangeTemplates = await CakeHive.openBox<ExchangeTemplate>(ExchangeTemplate.boxName);
   final anonpayInvoiceInfo = await CakeHive.openBox<AnonpayInvoiceInfo>(AnonpayInvoiceInfo.boxName);
@@ -483,3 +492,15 @@ Future<void> backgroundSync() async {
     }
   }
 }
+
+Future<void> checkAndStartFileMonitoring() async {
+  try {
+    final shouldMonitor = await FileExplorerViewModelBase.checkDevMonitorFileExists();
+    if (shouldMonitor) {
+      printV('Dev file monitoring enabled, starting file system watcher...');
+      await FileExplorerViewModelBase.startMonitoring();
+    }
+  } catch (e) {
+    printV('Failed to initialize file monitoring: $e');
+  }
+}
diff --git a/lib/router.dart b/lib/router.dart
index 1d04e0c005..962e41ab08 100644
--- a/lib/router.dart
+++ b/lib/router.dart
@@ -35,12 +35,14 @@ import 'package:cake_wallet/src/screens/dashboard/pages/address_page.dart';
 import 'package:cake_wallet/src/screens/dashboard/pages/nft_details_page.dart';
 import 'package:cake_wallet/src/screens/dashboard/pages/transactions_page.dart';
 import 'package:cake_wallet/src/screens/dashboard/sign_page.dart';
+import 'package:cake_wallet/src/screens/dev/file_explorer.dart';
 import 'package:cake_wallet/src/screens/dev/monero_background_sync.dart';
 import 'package:cake_wallet/src/screens/dev/moneroc_call_profiler.dart';
 import 'package:cake_wallet/src/screens/dev/network_requests.dart';
 import 'package:cake_wallet/src/screens/dev/secure_preferences_page.dart';
 import 'package:cake_wallet/src/screens/dev/shared_preferences_page.dart';
 import 'package:cake_wallet/src/screens/dev/background_sync_logs_page.dart';
+import 'package:cake_wallet/src/screens/dev/wallet_fuzzer.dart';
 import 'package:cake_wallet/src/screens/dev/socket_health_logs_page.dart';
 import 'package:cake_wallet/src/screens/disclaimer/disclaimer_page.dart';
 import 'package:cake_wallet/src/screens/disclaimer/third_party_disclaimer_page.dart';
@@ -944,6 +946,16 @@ Route<dynamic> createRoute(RouteSettings settings) {
         builder: (_) => getIt.get<DEuroSavingsPage>(),
       );
 
+    case Routes.devFileExplorer:
+      return MaterialPageRoute<void>(
+        builder: (_) => getIt.get<FileExplorerPage>(),
+      );
+
+    case Routes.devWalletFuzzer:
+      return MaterialPageRoute<void>(
+        builder: (_) => getIt.get<WalletFuzzerPage>(),
+      );
+
     default:
       return MaterialPageRoute<void>(
           builder: (_) => Scaffold(
diff --git a/lib/routes.dart b/lib/routes.dart
index 33196d98c9..d5317040fd 100644
--- a/lib/routes.dart
+++ b/lib/routes.dart
@@ -123,6 +123,8 @@ class Routes {
   static const devSocketHealthLogs = '/dev/socket_health_logs';
   static const devNetworkRequests = '/dev/network_requests';
 
+  static const devFileExplorer = '/dev/file_explorer';
+  static const devWalletFuzzer = '/dev/wallet_fuzzer';
   static const signPage = '/sign_page';
   static const connectDevices = '/device/connect';
   static const urqrAnimatedPage = '/urqr/animated_page';
diff --git a/lib/src/screens/dev/file_explorer.dart b/lib/src/screens/dev/file_explorer.dart
new file mode 100644
index 0000000000..39790d753b
--- /dev/null
+++ b/lib/src/screens/dev/file_explorer.dart
@@ -0,0 +1,1039 @@
+import 'package:cake_wallet/src/screens/base_page.dart';
+import 'package:cake_wallet/view_model/dev/file_explorer.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_mobx/flutter_mobx.dart';
+import 'dart:io';
+import 'package:path/path.dart' as p;
+import 'package:intl/intl.dart';
+import 'package:flutter/services.dart';
+import 'package:cake_wallet/utils/share_util.dart';
+import 'package:watcher/watcher.dart' as watcher;
+import 'package:cw_core/root_dir.dart';
+
+class FileExplorerPage extends BasePage {
+  FileExplorerPage();
+
+  @override
+  String? get title => "[dev] file explorer";
+
+  final viewModel = FileExplorerViewModel();
+
+  @override
+  Widget body(BuildContext context) {
+    return Observer(
+      builder: (_) {
+        return Column(
+          children: [
+            _buildTabBar(context),
+            Expanded(
+              child: _buildContent(context),
+            ),
+          ],
+        );
+      },
+    );
+  }
+
+  Widget _buildTabBar(BuildContext context) {
+    return Container(
+      color: Theme.of(context).primaryColor,
+      child: Row(
+        children: [
+          Expanded(
+            child: InkWell(
+              onTap: () => viewModel.switchToFileExplorer(),
+              child: Container(
+                padding: EdgeInsets.symmetric(vertical: 12),
+                alignment: Alignment.center,
+                decoration: BoxDecoration(
+                  border: Border(
+                    bottom: BorderSide(
+                      color: viewModel.viewMode == ViewMode.fileExplorer 
+                        ? Colors.white 
+                        : Colors.transparent,
+                      width: 2,
+                    ),
+                  ),
+                ),
+                child: Text(
+                  'Files',
+                  style: TextStyle(
+                    color: Colors.white,
+                    fontWeight: viewModel.viewMode == ViewMode.fileExplorer 
+                      ? FontWeight.bold 
+                      : FontWeight.normal,
+                  ),
+                ),
+              ),
+            ),
+          ),
+          Expanded(
+            child: InkWell(
+              onTap: () => viewModel.switchToSnapshots(),
+              child: Container(
+                padding: EdgeInsets.symmetric(vertical: 12),
+                alignment: Alignment.center,
+                decoration: BoxDecoration(
+                  border: Border(
+                    bottom: BorderSide(
+                      color: viewModel.viewMode == ViewMode.snapshots 
+                        ? Colors.white 
+                        : Colors.transparent,
+                      width: 2,
+                    ),
+                  ),
+                ),
+                child: Text(
+                  'Snapshots',
+                  style: TextStyle(
+                    color: Colors.white,
+                    fontWeight: viewModel.viewMode == ViewMode.snapshots 
+                      ? FontWeight.bold 
+                      : FontWeight.normal,
+                  ),
+                ),
+              ),
+            ),
+          ),
+          Expanded(
+            child: InkWell(
+              onTap: () => viewModel.switchToFileMonitor(),
+              child: Container(
+                padding: EdgeInsets.symmetric(vertical: 12),
+                alignment: Alignment.center,
+                decoration: BoxDecoration(
+                  border: Border(
+                    bottom: BorderSide(
+                      color: viewModel.viewMode == ViewMode.fileMonitor 
+                        ? Colors.white 
+                        : Colors.transparent,
+                      width: 2,
+                    ),
+                  ),
+                ),
+                child: Text(
+                  'Monitor',
+                  style: TextStyle(
+                    color: Colors.white,
+                    fontWeight: viewModel.viewMode == ViewMode.fileMonitor 
+                      ? FontWeight.bold 
+                      : FontWeight.normal,
+                  ),
+                ),
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildContent(BuildContext context) {
+    switch (viewModel.viewMode) {
+      case ViewMode.fileExplorer:
+        return _buildFileExplorer(context);
+      case ViewMode.snapshots:
+        return _buildSnapshotsList(context);
+      case ViewMode.hexdump:
+        return _buildHexDumpView(context);
+      case ViewMode.comparison:
+        return _buildSnapshotComparison(context);
+      case ViewMode.detailedComparison:
+        return _buildDetailedComparison(context);
+      case ViewMode.fileMonitor:
+        return _buildFileMonitor(context);
+    }
+  }
+
+  Widget _buildFileExplorer(BuildContext context) {
+    return Column(
+      children: [
+        _buildPathBar(context),
+        Expanded(
+          child: _buildFileList(context),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildPathBar(BuildContext context) {
+    return Container(
+      padding: EdgeInsets.all(8.0),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              IconButton(
+                icon: Icon(Icons.arrow_upward),
+                onPressed: viewModel.path == null ? null : () {
+                  viewModel.cd('..');
+                },
+                tooltip: 'Go up',
+              ),
+              Expanded(
+                child: Text(
+                  viewModel.path ?? 'Loading...',
+                  overflow: TextOverflow.ellipsis,
+                  style: TextStyle(fontWeight: FontWeight.bold),
+                ),
+              ),
+            ],
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildFileList(BuildContext context) {
+    if (viewModel.path == null) {
+      return Center(child: CircularProgressIndicator());
+    }
+
+    final directories = viewModel.directories;
+    final files = viewModel.files;
+
+    return ListView.builder(
+      itemCount: directories.length + files.length,
+      itemBuilder: (context, index) {
+        if (index < directories.length) {
+          // Directory item
+          final dirName = directories[index];
+          return ListTile(
+            leading: Icon(Icons.folder, color: Colors.amber),
+            title: Text(dirName),
+            onTap: () => viewModel.cd(dirName),
+          );
+        } else {
+          // File item
+          final fileIndex = index - directories.length;
+          final file = files[fileIndex];
+          final fileName = p.basename(file.path);
+          final fileSize = _getFileSize(file);
+
+          return ListTile(
+            leading: Icon(Icons.insert_drive_file, color: Colors.blue),
+            title: Text(fileName),
+            subtitle: Text(fileSize),
+            onTap: () {
+              viewModel.selectFile(file as File);
+            },
+            onLongPress: () => _showFileOptions(context, file as File),
+          );
+        }
+      },
+    );
+  }
+
+  Future<void> _showFileOptions(BuildContext context, File file) async {
+    final fileName = file.path;
+    
+    showModalBottomSheet(
+      context: context,
+      builder: (context) => SafeArea(
+        child: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            ListTile(
+              leading: Icon(Icons.edit),
+              title: Text('Rename/Move'),
+              onTap: () {
+                Navigator.pop(context);
+                _showRenameDialog(context, file);
+              },
+            ),
+            ListTile(
+              leading: Icon(Icons.copy),
+              title: Text('Copy'),
+              onTap: () {
+                Navigator.pop(context);
+                _showCopyDialog(context, file);
+              },
+            ),
+            ListTile(
+              leading: Icon(Icons.share),
+              title: Text('Share'),
+              onTap: () {
+                Navigator.pop(context);
+                ShareUtil.shareFile(
+                  filePath: file.path,
+                  fileName: fileName,
+                  context: context,
+                );
+              },
+            ),
+            ListTile(
+              leading: Icon(Icons.delete, color: Colors.red),
+              title: Text('Delete', style: TextStyle(color: Colors.red)),
+              onTap: () {
+                Navigator.pop(context);
+                _showDeleteConfirmation(context, file);
+              },
+            ),
+          ],
+        ),
+      ),
+    );
+  }
+
+  Future<void> _showRenameDialog(BuildContext context, File file) async {
+    final fileName = file.path;
+    final controller = TextEditingController(text: fileName);
+    
+    return showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text('Rename/Move File'),
+        content: TextField(
+          controller: controller,
+          decoration: InputDecoration(
+            labelText: 'New name/path',
+            hintText: 'Enter new name or path',
+          ),
+          autofocus: true,
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text('Cancel'),
+          ),
+          ElevatedButton(
+            onPressed: () async {
+              final newPath = controller.text.trim();
+              if (newPath.isNotEmpty) {
+                final success = await viewModel.renameFile(file.path, newPath);
+                Navigator.pop(context);
+                if (!success) {
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    SnackBar(content: Text('Failed to rename/move file')),
+                  );
+                }
+              }
+            },
+            child: Text('Rename'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _showCopyDialog(BuildContext context, File file) async {
+    final fileName = file.path;
+    final controller = TextEditingController(text: fileName);
+    
+    return showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text('Copy File'),
+        content: TextField(
+          controller: controller,
+          decoration: InputDecoration(
+            labelText: 'Destination name/path',
+            hintText: 'Enter destination name or path',
+          ),
+          autofocus: true,
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text('Cancel'),
+          ),
+          ElevatedButton(
+            onPressed: () async {
+              final newPath = controller.text.trim();
+              if (newPath.isNotEmpty) {
+                final success = await viewModel.copyFile(file.path, newPath);
+                Navigator.pop(context);
+                if (!success) {
+                  ScaffoldMessenger.of(context).showSnackBar(
+                    SnackBar(content: Text('Failed to copy file')),
+                  );
+                }
+              }
+            },
+            child: Text('Copy'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _showDeleteConfirmation(BuildContext context, File file) async {
+    return showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text('Delete File'),
+        content: Text('Are you sure you want to delete "${p.basename(file.path)}"?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text('Cancel'),
+          ),
+          ElevatedButton(
+            style: ElevatedButton.styleFrom(backgroundColor: Colors.red),
+            onPressed: () async {
+              final success = await viewModel.deleteFile(file.path);
+              Navigator.pop(context);
+              if (!success) {
+                ScaffoldMessenger.of(context).showSnackBar(
+                  SnackBar(content: Text('Failed to delete file')),
+                );
+              }
+            },
+            child: Text('Delete', style: TextStyle(color: Colors.white)),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildSnapshotsList(BuildContext context) {
+    return Column(
+      children: [
+        Padding(
+          padding: const EdgeInsets.all(8.0),
+          child: ElevatedButton(
+            onPressed: () {
+              _showCreateSnapshotDialog(context);
+            },
+            child: Text('Create New Snapshot'),
+          ),
+        ),
+        Expanded(
+          child: viewModel.snapshots.isEmpty
+            ? Center(child: Text('No snapshots yet. Create one to start!'))
+            : ListView.builder(
+                itemCount: viewModel.snapshots.length,
+                itemBuilder: (context, index) {
+                  final snapshot = viewModel.snapshots[index];
+                  final formattedDate = DateFormat('yyyy-MM-dd HH:mm').format(snapshot.timestamp);
+                  
+                  return ListTile(
+                    leading: Icon(Icons.camera_alt, color: Colors.green),
+                    title: Text(snapshot.name),
+                    subtitle: Text('$formattedDate - ${snapshot.files.length} files'),
+                    trailing: Row(
+                      mainAxisSize: MainAxisSize.min,
+                      children: [
+                        IconButton(
+                          icon: Icon(Icons.compare_arrows, color: Colors.orange),
+                          onPressed: () => viewModel.switchToComparison(snapshot),
+                          tooltip: 'Compare with current',
+                        ),
+                        IconButton(
+                          icon: Icon(Icons.delete, color: Colors.red),
+                          onPressed: () => _confirmDeleteSnapshot(context, snapshot),
+                          tooltip: 'Delete snapshot',
+                        ),
+                      ],
+                    ),
+                  );
+                },
+              ),
+        ),
+      ],
+    );
+  }
+
+  Future<void> _showCreateSnapshotDialog(BuildContext context) async {
+    final nameController = TextEditingController();
+    
+    return showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text('Create New Snapshot'),
+        content: TextField(
+          controller: nameController,
+          decoration: InputDecoration(
+            labelText: 'Snapshot Name',
+            hintText: 'Enter a name for this snapshot',
+          ),
+          autofocus: true,
+        ),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text('Cancel'),
+          ),
+          ElevatedButton(
+            onPressed: () {
+              final name = nameController.text.trim();
+              if (name.isNotEmpty) {
+                viewModel.createSnapshot(name);
+                Navigator.pop(context);
+              }
+            },
+            child: Text('Create'),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Future<void> _confirmDeleteSnapshot(BuildContext context, Snapshot snapshot) async {
+    return showDialog(
+      context: context,
+      builder: (context) => AlertDialog(
+        title: Text('Delete Snapshot'),
+        content: Text('Are you sure you want to delete the snapshot "${snapshot.name}"?'),
+        actions: [
+          TextButton(
+            onPressed: () => Navigator.pop(context),
+            child: Text('Cancel'),
+          ),
+          ElevatedButton(
+            style: ElevatedButton.styleFrom(backgroundColor: Colors.red),
+            onPressed: () {
+              viewModel.deleteSnapshot(snapshot);
+              Navigator.pop(context);
+            },
+            child: Text('Delete', style: TextStyle(color: Colors.white)),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildHexDumpView(BuildContext context) {
+    final file = viewModel.selectedFile;
+    
+    if (file == null) {
+      return Center(child: Text('No file selected'));
+    }
+    
+    return Column(
+      children: [
+        Container(
+          padding: EdgeInsets.all(8.0),
+          child: Row(
+            children: [
+              IconButton(
+                icon: Icon(Icons.arrow_back),
+                onPressed: () => viewModel.switchToFileExplorer(),
+                tooltip: 'Back to file list',
+              ),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      p.basename(file.path),
+                      style: TextStyle(fontWeight: FontWeight.bold),
+                      overflow: TextOverflow.ellipsis,
+                    ),
+                    Text(
+                      file.path,
+                      style: TextStyle(fontSize: 12),
+                      overflow: TextOverflow.ellipsis,
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+        Divider(),
+        Expanded(
+          child: FutureBuilder<String>(
+            future: viewModel.getHexDump(file, maxBytes: 128*1024),
+            builder: (context, snapshot) {
+              if (snapshot.connectionState == ConnectionState.waiting) {
+                return Center(child: CircularProgressIndicator());
+              }
+              
+              if (snapshot.hasError) {
+                return Center(child: Text('Error: ${snapshot.error}'));
+              }
+              
+              return SingleChildScrollView(
+                scrollDirection: Axis.horizontal,
+                child: SingleChildScrollView(
+                  child: Padding(
+                    padding: const EdgeInsets.all(8.0),
+                    child: SelectableText(
+                      snapshot.data ?? 'No data',
+                      style: TextStyle(
+                        fontFamily: 'monospace',
+                        fontSize: 14,
+                      ),
+                    ),
+                  ),
+                ),
+              );
+            },
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildSnapshotComparison(BuildContext context) {
+    final snapshot = viewModel.comparisonSnapshot;
+    
+    if (snapshot == null) {
+      return Center(child: Text('No snapshot selected for comparison'));
+    }
+    
+    return Column(
+      children: [
+        Container(
+          padding: EdgeInsets.all(8.0),
+          child: Row(
+            children: [
+              IconButton(
+                icon: Icon(Icons.arrow_back),
+                onPressed: () => viewModel.switchToSnapshots(),
+                tooltip: 'Back to snapshots',
+              ),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Text(
+                      'Comparing with: ${snapshot.name}',
+                      style: TextStyle(fontWeight: FontWeight.bold),
+                      overflow: TextOverflow.ellipsis,
+                    ),
+                    Text(
+                      'Created: ${DateFormat('yyyy-MM-dd HH:mm').format(snapshot.timestamp)}',
+                      style: TextStyle(fontSize: 12),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+        Divider(),
+        Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
+          child: Row(
+            children: [
+              _buildChangeBadge(
+                Colors.green, 
+                viewModel.fileChanges.where((change) => change.type == ChangeType.added).length
+              ),
+              SizedBox(width: 16),
+              _buildChangeBadge(
+                Colors.blue, 
+                viewModel.fileChanges.where((change) => change.type == ChangeType.touched).length
+              ),
+              SizedBox(width: 16),
+              _buildChangeBadge(
+                Colors.orange, 
+                viewModel.fileChanges.where((change) => change.type == ChangeType.modified).length
+              ),
+              SizedBox(width: 16),
+              _buildChangeBadge(
+                Colors.red, 
+                viewModel.fileChanges.where((change) => change.type == ChangeType.removed).length
+              ),
+            ],
+          ),
+        ),
+        Expanded(
+          child: viewModel.fileChanges.isEmpty
+            ? Center(child: Text('No changes detected'))
+            : ListView.builder(
+                itemCount: viewModel.fileChanges.length,
+                itemBuilder: (context, index) {
+                  final change = viewModel.fileChanges[index];
+                  final icon = _getChangeIcon(change.type);
+                  final color = _getChangeColor(change.type);
+                  
+                  String details = '';
+                  switch (change.type) {
+                    case ChangeType.modified:
+                      final oldSize = _formatFileSize(change.oldFile!.size);
+                      final newSize = _formatFileSize(change.newFile!.size);
+                      details = 'Size: $oldSize → $newSize';
+                      break;
+                    case ChangeType.added:
+                      details = 'Size: ${_formatFileSize(change.newFile!.size)}';
+                      break;
+                    case ChangeType.removed:
+                      details = 'Size: ${_formatFileSize(change.oldFile!.size)}';
+                      break;
+                    case ChangeType.touched:
+                      details = 'Modified timestamp changed';
+                      break;
+                  }
+                  
+                  return ListTile(
+                    leading: Icon(icon, color: color),
+                    title: Text(change.path),
+                    subtitle: Text(details),
+                    trailing: Text(
+                      change.type.toString().split('.').last,
+                      style: TextStyle(
+                        color: color,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    onTap: () => viewModel.switchToDetailedComparison(change),
+                  );
+                },
+              ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildDetailedComparison(BuildContext context) {
+    final fileChange = viewModel.selectedFileChange;
+    
+    if (fileChange == null) {
+      return Center(child: Text('No file selected for detailed comparison'));
+    }
+    
+    final color = _getChangeColor(fileChange.type);
+    final icon = _getChangeIcon(fileChange.type);
+    
+    return Column(
+      children: [
+        Container(
+          padding: EdgeInsets.all(8.0),
+          child: Row(
+            children: [
+              IconButton(
+                icon: Icon(Icons.arrow_back),
+                onPressed: () => viewModel.viewMode = ViewMode.comparison,
+                tooltip: 'Back to changes list',
+              ),
+              Expanded(
+                child: Column(
+                  crossAxisAlignment: CrossAxisAlignment.start,
+                  children: [
+                    Row(
+                      children: [
+                        Icon(icon, color: color, size: 16),
+                        SizedBox(width: 8),
+                        Expanded(
+                          child: Text(
+                            fileChange.path,
+                            style: TextStyle(fontWeight: FontWeight.bold),
+                            overflow: TextOverflow.ellipsis,
+                          ),
+                        ),
+                      ],
+                    ),
+                    Text(
+                      'Status: ${fileChange.type.toString().split('.').last}',
+                      style: TextStyle(
+                        fontSize: 12,
+                        color: color,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                  ],
+                ),
+              ),
+            ],
+          ),
+        ),
+        Divider(),
+        Expanded(
+          child: FutureBuilder<String>(
+            future: viewModel.getFileDiff(fileChange),
+            builder: (context, snapshot) {
+              if (snapshot.connectionState == ConnectionState.waiting) {
+                return Center(
+                  child: Column(
+                    mainAxisAlignment: MainAxisAlignment.center,
+                    children: [
+                      CircularProgressIndicator(),
+                      SizedBox(height: 16),
+                      Text('Loading file diff (may take time for large files)...'),
+                    ],
+                  ),
+                );
+              }
+              
+              if (snapshot.hasError) {
+                return Center(child: Text('Error: ${snapshot.error}'));
+              }
+              
+              final diffText = snapshot.data ?? 'No data available';
+              
+              return Stack(
+                children: [
+                  SingleChildScrollView(
+                    scrollDirection: Axis.horizontal,
+                    child: SingleChildScrollView(
+                      child: Padding(
+                        padding: const EdgeInsets.all(8.0),
+                        child: SelectableText(
+                          diffText,
+                          style: TextStyle(
+                            fontFamily: 'monospace',
+                            fontSize: 14,
+                          ),
+                        ),
+                      ),
+                    ),
+                  ),
+                  FloatingActionButton(
+                    mini: true,
+                    child: Icon(Icons.copy),
+                    onPressed: () {
+                      final data = ClipboardData(text: diffText);
+                      Clipboard.setData(data);
+                      ScaffoldMessenger.of(context).showSnackBar(
+                        SnackBar(content: Text('Diff copied to clipboard')),
+                      );
+                    },
+                    tooltip: 'Copy diff to clipboard',
+                  ),
+                ],
+              );
+            },
+          ),
+        ),
+      ],
+    );
+  }
+
+  Widget _buildChangeBadge(Color color, int count) {
+    return Container(
+      padding: EdgeInsets.symmetric(horizontal: 12, vertical: 6),
+      decoration: BoxDecoration(
+        color: color.withOpacity(0.2),
+        borderRadius: BorderRadius.circular(16),
+        border: Border.all(color: color),
+      ),
+      child: Row(
+        children: [
+          Container(
+            padding: EdgeInsets.all(4),
+            decoration: BoxDecoration(
+              color: color,
+              shape: BoxShape.circle,
+            ),
+            child: Text(
+              count.toString(),
+              style: TextStyle(
+                color: Colors.white,
+                fontSize: 12,
+                fontWeight: FontWeight.bold,
+              ),
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  IconData _getChangeIcon(ChangeType type) {
+    switch (type) {
+      case ChangeType.added:
+        return Icons.add_circle;
+      case ChangeType.removed:
+        return Icons.remove_circle;
+      case ChangeType.modified:
+        return Icons.edit;
+      case ChangeType.touched:
+        return Icons.access_time;
+    }
+  }
+
+  Color _getChangeColor(ChangeType type) {
+    switch (type) {
+      case ChangeType.added:
+        return Colors.green;
+      case ChangeType.removed:
+        return Colors.red;
+      case ChangeType.modified:
+        return Colors.orange;
+      case ChangeType.touched:
+        return Colors.blue;
+    }
+  }
+
+  String _formatFileSize(int sizeInBytes) {
+    if (sizeInBytes < 1024) {
+      return '$sizeInBytes B';
+    } else if (sizeInBytes < 1024 * 1024) {
+      return '${(sizeInBytes / 1024).toStringAsFixed(2)} KB';
+    } else if (sizeInBytes < 1024 * 1024 * 1024) {
+      return '${(sizeInBytes / (1024 * 1024)).toStringAsFixed(2)} MB';
+    } else if (sizeInBytes < 1024 * 1024 * 1024 * 1024) {
+      return '${(sizeInBytes / (1024 * 1024 * 1024)).toStringAsFixed(2)} GB';
+    } else {
+      return '${(sizeInBytes / (1024 * 1024 * 1024 * 1024)).toStringAsFixed(2)} TB... why?';
+    }
+  }
+
+  String _getFileSize(FileSystemEntity entity) {
+    try {
+      final file = File(entity.path);
+      final fileSizeInBytes = file.lengthSync();
+      return _formatFileSize(fileSizeInBytes);
+    } catch (e) {
+      return 'Error getting size';
+    }
+  }
+
+  Widget _buildFileMonitor(BuildContext context) {
+    return Column(
+      children: [
+        Padding(
+          padding: const EdgeInsets.all(8.0),
+          child: Row(
+            children: [
+              Expanded(
+                child: Text(
+                  'Monitoring file system events',
+                  style: TextStyle(fontWeight: FontWeight.bold),
+                ),
+              ),
+              Switch(
+                value: FileExplorerViewModelBase.isMonitoringActive,
+                onChanged: (value) {
+                  if (value) {
+                    FileExplorerViewModelBase.startMonitoring();
+                  } else {
+                    FileExplorerViewModelBase.stopMonitoring();
+                  }
+                },
+              ),
+              SizedBox(width: 8),
+              IconButton(
+                icon: Icon(Icons.delete_sweep),
+                onPressed: () => viewModel.clearEvents(),
+                tooltip: 'Clear events',
+              ),
+              IconButton(
+                icon: Icon(Icons.restart_alt),
+                onPressed: () => _toggleDevMonitorFile(context),
+                tooltip: 'Toggle monitoring on app start',
+              ),
+            ],
+          ),
+        ),
+        Divider(),
+        FutureBuilder<bool>(
+          future: FileExplorerViewModelBase.checkDevMonitorFileExists(),
+          builder: (context, snapshot) {
+            if (snapshot.connectionState == ConnectionState.waiting) {
+              return SizedBox.shrink();
+            }
+            
+            final devFileExists = snapshot.data ?? false;
+            
+            return Padding(
+              padding: const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
+              child: Row(
+                children: [
+                  Icon(
+                    devFileExists ? Icons.check_circle : Icons.cancel,
+                    color: devFileExists ? Colors.green : Colors.red,
+                    size: 16,
+                  ),
+                  SizedBox(width: 8),
+                  Expanded(
+                    child: Text(
+                      devFileExists 
+                        ? 'Monitor file exists - will start on app launch' 
+                        : 'Monitor file does not exist - will not start on app launch',
+                      style: TextStyle(fontSize: 12),
+                    ),
+                  ),
+                ],
+              ),
+            );
+          },
+        ),
+        Divider(),
+        Expanded(
+          child: Observer(
+            builder: (_) {
+              final events = FileExplorerViewModelBase.fileEvents;
+              
+              if (events.isEmpty) {
+                return Center(
+                  child: Text('No events recorded yet. Toggle monitoring to start.'),
+                );
+              }
+              
+              return ListView.builder(
+                itemCount: events.length,
+                itemBuilder: (context, index) {
+                  final event = events[events.length - 1 - index]; // Show newest first
+                  final icon = _getFileEventIcon(event.event.type);
+                  final color = _getFileEventColor(event.event.type);
+                  final formattedTime = DateFormat('HH:mm:ss.SSS').format(event.timestamp);
+                  
+                  return ListTile(
+                    leading: Icon(icon, color: color),
+                    title: Text(
+                      event.relativePath,
+                      style: TextStyle(
+                        fontWeight: FontWeight.bold,
+                        fontSize: 14,
+                      ),
+                    ),
+                    subtitle: Text(
+                      '${event.event.type.toString().split('.').last} at $formattedTime',
+                      style: TextStyle(fontSize: 12),
+                    ),
+                    trailing: Text(
+                      event.event.type.toString().split('.').last,
+                      style: TextStyle(
+                        color: color,
+                        fontWeight: FontWeight.bold,
+                      ),
+                    ),
+                    dense: true,
+                  );
+                },
+              );
+            },
+          ),
+        ),
+      ],
+    );
+  }
+  
+  IconData _getFileEventIcon(watcher.ChangeType type) {
+    switch (type) {
+      case watcher.ChangeType.ADD:
+        return Icons.add_circle;
+      case watcher.ChangeType.REMOVE:
+        return Icons.remove_circle;
+      case watcher.ChangeType.MODIFY:
+        return Icons.edit;
+      default:
+        return Icons.help_outline;
+    }
+  }
+  
+  Color _getFileEventColor(watcher.ChangeType type) {
+    switch (type) {
+      case watcher.ChangeType.ADD:
+        return Colors.green;
+      case watcher.ChangeType.REMOVE:
+        return Colors.red;
+      case watcher.ChangeType.MODIFY:
+        return Colors.orange;
+      default:
+        return Colors.grey;
+    }
+  }
+
+  Future<void> _toggleDevMonitorFile(BuildContext context) async {
+    final appDir = await getAppDir();
+    final devMonitorFile = File('${appDir.path}/.dev-monitor-fs');
+    
+    if (await devMonitorFile.exists()) {
+      await devMonitorFile.delete();
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('File monitoring disabled. App restart required.')),
+      );
+    } else {
+      await devMonitorFile.create();
+      ScaffoldMessenger.of(context).showSnackBar(
+        SnackBar(content: Text('File monitoring enabled. App restart required.')),
+      );
+    }
+  }
+}
diff --git a/lib/src/screens/dev/wallet_fuzzer.dart b/lib/src/screens/dev/wallet_fuzzer.dart
new file mode 100644
index 0000000000..d6f71f81d0
--- /dev/null
+++ b/lib/src/screens/dev/wallet_fuzzer.dart
@@ -0,0 +1,238 @@
+import 'package:cake_wallet/src/screens/base_page.dart';
+import 'package:cake_wallet/view_model/dev/wallet_fuzzer.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_mobx/flutter_mobx.dart';
+import 'package:intl/intl.dart';
+
+class WalletFuzzerPage extends BasePage {
+  WalletFuzzerPage();
+
+  @override
+  String? get title => "[dev] wallet fuzzer";
+
+  final viewModel = WalletFuzzerViewModel();
+
+  @override
+  Widget body(BuildContext context) {
+    return Observer(
+      builder: (_) {
+        return Column(
+          children: [
+            _buildStatusBar(context),
+            Expanded(
+              child: _buildLogsList(context),
+            ),
+            _buildControls(context),
+          ],
+        );
+      },
+    );
+  }
+
+  Widget _buildStatusBar(BuildContext context) {
+    return Container(
+      padding: EdgeInsets.all(8.0),
+      color: Theme.of(context).primaryColor,
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              Icon(
+                viewModel.isRunning ? Icons.warning_amber : Icons.info_outline,
+                color: viewModel.isRunning ? Colors.amber : Colors.white,
+              ),
+              SizedBox(width: 8),
+              Expanded(
+                child: Text(
+                  'Status: ${viewModel.isRunning ? "RUNNING" : "Stopped"}',
+                  style: TextStyle(
+                    color: Colors.white,
+                    fontWeight: FontWeight.bold,
+                  ),
+                ),
+              ),
+              Container(
+                padding: EdgeInsets.symmetric(horizontal: 8, vertical: 2),
+                decoration: BoxDecoration(
+                  color: viewModel.isRunning ? Colors.green.withOpacity(0.3) : Colors.red.withOpacity(0.3),
+                  borderRadius: BorderRadius.circular(12),
+                  border: Border.all(
+                    color: viewModel.isRunning ? Colors.green : Colors.red,
+                  ),
+                ),
+                child: Text(
+                  'Ops: ${viewModel.operationsCompleted}',
+                  style: TextStyle(
+                    color: Colors.white,
+                    fontSize: 12,
+                  ),
+                ),
+              ),
+              SizedBox(width: 8),
+              Container(
+                padding: EdgeInsets.symmetric(horizontal: 8, vertical: 2),
+                decoration: BoxDecoration(
+                  color: Colors.red.withOpacity(0.3),
+                  borderRadius: BorderRadius.circular(12),
+                  border: Border.all(color: Colors.red),
+                ),
+                child: Text(
+                  'Errors: ${viewModel.errorsEncountered}',
+                  style: TextStyle(
+                    color: Colors.white,
+                    fontSize: 12,
+                  ),
+                ),
+              ),
+            ],
+          ),
+          SizedBox(height: 8),
+          Text(
+            'Current Operation: ${viewModel.currentOperation}',
+            style: TextStyle(color: Colors.white),
+          ),
+          Text(
+            'Current Wallet: ${viewModel.currentWallet.isEmpty ? "none" : viewModel.currentWallet}',
+            style: TextStyle(color: Colors.white),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildLogsList(BuildContext context) {
+    return Container(
+      padding: EdgeInsets.all(8.0),
+      child: Column(
+        crossAxisAlignment: CrossAxisAlignment.start,
+        children: [
+          Row(
+            children: [
+              Expanded(
+                child: Text(
+                  'Logs:',
+                  style: TextStyle(fontWeight: FontWeight.bold),
+                ),
+              ),
+              IconButton(
+                icon: Icon(Icons.delete_sweep),
+                onPressed: () => viewModel.clearLogs(),
+                tooltip: 'Clear logs',
+              ),
+            ],
+          ),
+          Divider(),
+          Expanded(
+            child: viewModel.logs.isEmpty
+                ? Center(child: Text('No logs yet. Start fuzzing to see logs.'))
+                : ListView.builder(
+                    itemCount: viewModel.logs.length,
+                    itemBuilder: (context, index) {
+                      final log = viewModel.logs[index];
+                      final formattedTime = DateFormat('HH:mm:ss').format(log.timestamp);
+                      
+                      Color logColor = Colors.black;
+                      if (log.action.contains('Error') || log.result?.contains('Error') == true || log.result?.contains('error') == true) {
+                        logColor = Colors.red;
+                      } else if (log.action.contains('Success') || log.action.contains('successfully')) {
+                        logColor = Colors.green;
+                      }
+                      
+                      return Padding(
+                        padding: EdgeInsets.symmetric(vertical: 2),
+                        child: Row(
+                          crossAxisAlignment: CrossAxisAlignment.start,
+                          children: [
+                            Text(
+                              formattedTime,
+                              style: TextStyle(
+                                fontSize: 12,
+                                color: Colors.grey,
+                              ),
+                            ),
+                            SizedBox(width: 8),
+                            Expanded(
+                              child: log.result != null
+                                  ? RichText(
+                                      text: TextSpan(
+                                        style: DefaultTextStyle.of(context).style,
+                                        children: [
+                                          TextSpan(
+                                            text: '${log.action} - ',
+                                            style: TextStyle(color: logColor),
+                                          ),
+                                          TextSpan(
+                                            text: log.result,
+                                            style: TextStyle(
+                                              color: logColor,
+                                              fontWeight: FontWeight.bold,
+                                            ),
+                                          ),
+                                        ],
+                                      ),
+                                    )
+                                  : Text(
+                                      log.action,
+                                      style: TextStyle(color: logColor),
+                                    ),
+                            ),
+                          ],
+                        ),
+                      );
+                    },
+                  ),
+          ),
+        ],
+      ),
+    );
+  }
+
+  Widget _buildControls(BuildContext context) {
+    return Container(
+      padding: EdgeInsets.all(16.0),
+      decoration: BoxDecoration(
+        color: Theme.of(context).scaffoldBackgroundColor,
+        boxShadow: [
+          BoxShadow(
+            color: Colors.black.withOpacity(0.1),
+            spreadRadius: 1,
+            blurRadius: 3,
+            offset: Offset(0, -1),
+          ),
+        ],
+      ),
+      child: Column(
+        children: [
+          Row(
+            children: [
+              Expanded(
+                child: ElevatedButton(
+                  style: ElevatedButton.styleFrom(
+                    backgroundColor: viewModel.isRunning ? Colors.red : Colors.green,
+                    padding: EdgeInsets.symmetric(vertical: 12),
+                  ),
+                  onPressed: () {
+                    if (viewModel.isRunning) {
+                      viewModel.stopFuzzing();
+                    } else {
+                      viewModel.startFuzzing();
+                    }
+                  },
+                  child: Text(
+                    viewModel.isRunning ? 'STOP FUZZING' : 'START FUZZING',
+                    style: TextStyle(
+                      color: Colors.white,
+                      fontWeight: FontWeight.bold,
+                    ),
+                  ),
+                ),
+              ),
+            ],
+          ),
+          SizedBox(height: 8),
+        ],
+      ),
+    );
+  }
+} 
\ No newline at end of file
diff --git a/lib/src/screens/settings/other_settings_page.dart b/lib/src/screens/settings/other_settings_page.dart
index 1991ee289e..036a1739c2 100644
--- a/lib/src/screens/settings/other_settings_page.dart
+++ b/lib/src/screens/settings/other_settings_page.dart
@@ -75,6 +75,18 @@ class OtherSettingsPage extends BasePage {
                   handler: (BuildContext context) =>
                       Navigator.of(context).pushNamed(Routes.devMoneroCallProfiler),
                 ),
+              if (FeatureFlag.hasDevOptions)
+                SettingsCellWithArrow(
+                  title: '[dev] file explorer',
+                  handler: (BuildContext context) =>
+                      Navigator.of(context).pushNamed(Routes.devFileExplorer),
+                ),
+              if (FeatureFlag.hasDevOptions)
+                SettingsCellWithArrow(
+                  title: '[dev] wallet fuzzer',
+                  handler: (BuildContext context) =>
+                      Navigator.of(context).pushNamed(Routes.devWalletFuzzer),
+                ),
               if (FeatureFlag.hasDevOptions)
                 SettingsCellWithArrow(
                   title: '[dev] shared preferences',
@@ -93,6 +105,18 @@ class OtherSettingsPage extends BasePage {
                   handler: (BuildContext context) =>
                       Navigator.of(context).pushNamed(Routes.devBackgroundSyncLogs),
                 ),
+              if (FeatureFlag.hasDevOptions)
+                SettingsCellWithArrow(
+                  title: '[dev] file explorer',
+                  handler: (BuildContext context) =>
+                      Navigator.of(context).pushNamed(Routes.devFileExplorer),
+                ),
+              if (FeatureFlag.hasDevOptions)
+                SettingsCellWithArrow(
+                  title: '[dev] wallet fuzzer',
+                  handler: (BuildContext context) =>
+                      Navigator.of(context).pushNamed(Routes.devWalletFuzzer),
+                ),
               if (FeatureFlag.hasDevOptions)
                 SettingsCellWithArrow(
                   title: '[dev] socket health logs',
diff --git a/lib/view_model/dev/file_explorer.dart b/lib/view_model/dev/file_explorer.dart
new file mode 100644
index 0000000000..29e009a8c9
--- /dev/null
+++ b/lib/view_model/dev/file_explorer.dart
@@ -0,0 +1,967 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:convert';
+import 'dart:typed_data';
+
+import 'package:cw_core/root_dir.dart';
+import 'package:cw_core/utils/print_verbose.dart';
+import 'package:mobx/mobx.dart';
+import 'package:path/path.dart' as p;
+import 'package:watcher/watcher.dart';
+
+part 'file_explorer.g.dart';
+
+class FileExplorerViewModel = FileExplorerViewModelBase with _$FileExplorerViewModel;
+
+class Snapshot {
+  final String name;
+  final DateTime timestamp;
+  final Map<String, FileInfo> files;
+
+  Snapshot({required this.name, required this.timestamp, required this.files});
+}
+
+class FileInfo {
+  final String path;
+  final int size;
+  final DateTime modified;
+  final Uint8List? content;
+
+  FileInfo({
+    required this.path, 
+    required this.size, 
+    required this.modified, 
+    this.content
+  });
+}
+
+class FileChange {
+  final String path;
+  final ChangeType type;
+  final FileInfo? oldFile;
+  final FileInfo? newFile;
+
+  FileChange({required this.path, required this.type, this.oldFile, this.newFile});
+}
+
+enum ChangeType { added, removed, modified, touched }
+
+enum ViewMode { fileExplorer, snapshots, hexdump, comparison, detailedComparison, fileMonitor }
+
+class FileEvent {
+  final DateTime timestamp;
+  final WatchEvent event;
+  final String relativePath;
+
+  FileEvent({required this.timestamp, required this.event, required this.relativePath});
+}
+
+abstract class FileExplorerViewModelBase with Store {
+  FileExplorerViewModelBase() {
+    unawaited(_initialize());
+  }
+
+  static ObservableList<FileEvent> fileEvents = ObservableList<FileEvent>();
+  
+  static DirectoryWatcher? _watcher;
+  
+  static bool isMonitoringActive = false;
+
+  @observable
+  String? path;
+
+  @observable
+  String? rootPath;
+
+  @observable
+  String? snapshotsPath;
+
+  @observable
+  File? selectedFile;
+
+  @observable
+  ObservableList<Snapshot> snapshots = ObservableList<Snapshot>();
+
+  @observable
+  ViewMode viewMode = ViewMode.fileExplorer;
+
+  @observable
+  Snapshot? comparisonSnapshot;
+
+  @observable
+  ObservableList<FileChange> fileChanges = ObservableList<FileChange>();
+  
+  @observable
+  FileChange? selectedFileChange;
+
+  static const int MAX_FILE_SIZE = 1 * 1024 * 1024;
+
+  static const int CHUNK_SIZE = 16 * 1024;
+
+  @action
+  Future<void> _initialize() async {
+    rootPath = (await getAppDir()).path;
+    path = rootPath;
+    snapshotsPath = p.join(rootPath!, 'snapshots');
+    
+    final dir = Directory(snapshotsPath!);
+    if (!await dir.exists()) {
+      await dir.create(recursive: true);
+    }
+    
+    await loadSnapshots();
+  }
+
+  @computed
+  List<FileSystemEntity> get files {
+    if (path == null) {
+      return [];
+    }
+    
+    final dir = Directory(path!);
+    final entities = dir.listSync();
+    return entities.where((entity) => entity is File).toList();
+  }
+
+  @computed
+  List<String> get directories {
+    if (path == null) {
+      return [];
+    }
+    
+    final dir = Directory(path!);
+    final entities = dir.listSync();
+    return entities.where((entity) => entity is Directory).map((entity) => p.basename(entity.path)).toList();
+  }
+
+  @action
+  void cd(String newPath) {
+    try {
+      if (path == null) {
+        return;
+      }
+      final Directory directory = Directory(p.join(path!, newPath));
+      final String path2 = directory.absolute.path;
+      
+      final String normalizedPath = p.normalize(path2);
+      final String normalizedRootPath = p.normalize(rootPath!);
+      
+      final bool isWithinRoot = normalizedPath.startsWith(normalizedRootPath);
+      if (!isWithinRoot) {
+        path = rootPath;
+      } else {
+        path = path2;
+      }
+    } catch (e) {
+      path = rootPath;
+    }
+  }
+
+  @action
+  void selectFile(File file) {
+    selectedFile = file;
+    viewMode = ViewMode.hexdump;
+  }
+
+  @action
+  void switchToFileExplorer() {
+    viewMode = ViewMode.fileExplorer;
+  }
+
+  @action
+  void switchToSnapshots() {
+    viewMode = ViewMode.snapshots;
+  }
+
+  @action
+  void switchToComparison(Snapshot snapshot) {
+    comparisonSnapshot = snapshot;
+    viewMode = ViewMode.comparison;
+    compareSnapshot();
+  }
+
+  @action
+  void switchToDetailedComparison(FileChange fileChange) {
+    selectedFileChange = fileChange;
+    viewMode = ViewMode.detailedComparison;
+  }
+
+  @action
+  void switchToFileMonitor() {
+    viewMode = ViewMode.fileMonitor;
+  }
+
+  Future<String> getHexDump(File file, {int? maxBytes}) async {
+    try {
+      final bytes = await file.readAsBytes();
+      final bytesToRead = maxBytes != null && bytes.length > maxBytes ? maxBytes : bytes.length;
+      final buffer = StringBuffer();
+      
+      for (var i = 0; i < bytesToRead; i += 16) {
+        // Address
+        buffer.write('${i.toRadixString(16).padLeft(8, '0')}: ');
+        
+        // Hex values
+        for (var j = 0; j < 16; j++) {
+          if (i + j < bytesToRead) {
+            buffer.write('${bytes[i + j].toRadixString(16).padLeft(2, '0')} ');
+          } else {
+            buffer.write('   ');
+          }
+          if (j == 7) buffer.write(' ');
+        }
+        
+        // ASCII representation
+        buffer.write(' |');
+        for (var j = 0; j < 16; j++) {
+          if (i + j < bytesToRead) {
+            final char = bytes[i + j];
+            // Show printable ASCII characters
+            if (char >= 32 && char <= 126) {
+              buffer.write(String.fromCharCode(char));
+            } else {
+              buffer.write('.');
+            }
+          } else {
+            buffer.write(' ');
+          }
+        }
+        buffer.write('|\n');
+      }
+      
+      if (maxBytes != null && bytes.length > maxBytes) {
+        buffer.write('\n... (${bytes.length - maxBytes} more bytes) ...');
+      }
+      
+      return buffer.toString();
+    } catch (e) {
+      return 'Error reading file: $e';
+    }
+  }
+
+  Future<Uint8List> getFileBytes(String filePath) async {
+    try {
+      final file = File(filePath);
+      return await file.readAsBytes();
+    } catch (e) {
+      printV('Error reading file bytes: $e');
+      return Uint8List(0);
+    }
+  }
+
+  Future<String> getHexDiffDump(Uint8List oldBytes, Uint8List newBytes) async {
+    final buffer = StringBuffer();
+    final maxLength = oldBytes.length > newBytes.length ? oldBytes.length : newBytes.length;
+    final minLength = oldBytes.length < newBytes.length ? oldBytes.length : newBytes.length;
+    
+    // Standard for hexdump displays
+    final chunkSize = 16; 
+
+    int totalBlocks = (maxLength / chunkSize).ceil();
+    int diffBlocks = 0;
+    int sameBlocks = 0;
+    
+    buffer.writeln('=== Binary Diff Summary ===');
+    buffer.writeln('Old size: ${_formatSize(oldBytes.length)}');
+    buffer.writeln('New size: ${_formatSize(newBytes.length)}');
+    buffer.writeln('Size difference: ${_formatSizeDifference(newBytes.length - oldBytes.length)}');
+    buffer.writeln('');
+    buffer.writeln('=== Changed Blocks Only ===');
+    
+    for (var i = 0; i < maxLength; i += chunkSize) {
+      bool hasBlockDiff = false;
+      final blockEnd = i + chunkSize < maxLength ? i + chunkSize : maxLength;
+      
+      for (var j = i; j < blockEnd && j < minLength; j++) {
+        if (j < oldBytes.length && j < newBytes.length && oldBytes[j] != newBytes[j]) {
+          hasBlockDiff = true;
+          break;
+        }
+      }
+      
+      if (i >= oldBytes.length || i >= newBytes.length) {
+        hasBlockDiff = true;
+      }
+      
+      if (hasBlockDiff) {
+        diffBlocks++;
+        
+        if (i < oldBytes.length) {
+          buffer.write('- ');
+          buffer.write('${i.toRadixString(16).padLeft(8, '0')}: ');
+          
+          for (var j = 0; j < chunkSize; j++) {
+            if (i + j < oldBytes.length) {
+              final byteValue = oldBytes[i + j].toRadixString(16).padLeft(2, '0');
+              if (i + j < newBytes.length && oldBytes[i + j] != newBytes[i + j]) {
+                buffer.write('[$byteValue] ');
+              } else {
+                buffer.write(' $byteValue  ');
+              }
+            } else {
+              buffer.write('     ');
+            }
+            if (j == 7) buffer.write(' ');
+          }
+          
+          buffer.write(' |');
+          for (var j = 0; j < chunkSize; j++) {
+            if (i + j < oldBytes.length) {
+              final char = oldBytes[i + j];
+              if (char >= 32 && char <= 126) {
+                if (i + j < newBytes.length && oldBytes[i + j] != newBytes[i + j]) {
+                  buffer.write('[${String.fromCharCode(char)}]');
+                } else {
+                  buffer.write(' ${String.fromCharCode(char)} ');
+                }
+              } else {
+                buffer.write(' . ');
+              }
+            } else {
+              buffer.write('   ');
+            }
+          }
+          buffer.write('|\n');
+        }
+        
+        if (i < newBytes.length) {
+          buffer.write('+ ');
+          buffer.write('${i.toRadixString(16).padLeft(8, '0')}: ');
+          
+          for (var j = 0; j < chunkSize; j++) {
+            if (i + j < newBytes.length) {
+              final byteValue = newBytes[i + j].toRadixString(16).padLeft(2, '0');
+              if (i + j < oldBytes.length && oldBytes[i + j] != newBytes[i + j]) {
+                buffer.write('[$byteValue] ');
+              } else if (i + j >= oldBytes.length) {
+                buffer.write('*$byteValue* ');
+              } else {
+                buffer.write(' $byteValue  ');
+              }
+            } else {
+              buffer.write('     ');
+            }
+            if (j == 7) buffer.write(' ');
+          }
+          
+          buffer.write(' |');
+          for (var j = 0; j < chunkSize; j++) {
+            if (i + j < newBytes.length) {
+              final char = newBytes[i + j];
+              if (char >= 32 && char <= 126) {
+                if (i + j < oldBytes.length && oldBytes[i + j] != newBytes[i + j]) {
+                  buffer.write('[${String.fromCharCode(char)}]');
+                } else if (i + j >= oldBytes.length) {
+                  buffer.write('*${String.fromCharCode(char)}*');
+                } else {
+                  buffer.write(' ${String.fromCharCode(char)} ');
+                }
+              } else {
+                buffer.write(' . ');
+              }
+            } else {
+              buffer.write('   ');
+            }
+          }
+          buffer.write('|\n');
+        }
+
+        buffer.write('\n');
+      } else {
+        sameBlocks++;
+      }
+    }
+    
+    buffer.writeln('=== Diff Summary ===');
+    buffer.writeln('Total blocks: $totalBlocks');
+    buffer.writeln('Different blocks: $diffBlocks');
+    buffer.writeln('Identical blocks: $sameBlocks');
+    buffer.writeln('Difference percentage: ${(diffBlocks / totalBlocks * 100).toStringAsFixed(2)}%');
+    
+    return buffer.toString();
+  }
+
+  Future<String> compareFilesStreamBased(File currentFile, FileInfo oldInfo) async {
+    final buffer = StringBuffer();
+    final filePath = currentFile.path;
+    final fileSize = await currentFile.length();
+    
+    if (fileSize > MAX_FILE_SIZE) {
+      return 'File too large to diff (${_formatSize(fileSize)}). Maximum size: ${_formatSize(MAX_FILE_SIZE)}.';
+    }
+    
+    buffer.writeln('=== Binary Diff of ${p.basename(filePath)} ===');
+    buffer.writeln('Path: ${p.relative(filePath, from: rootPath!)}');
+    buffer.writeln('Old size: ${_formatSize(oldInfo.size)}');
+    buffer.writeln('New size: ${_formatSize(fileSize)}');
+    buffer.writeln('Size difference: ${_formatSizeDifference(fileSize - oldInfo.size)}');
+    buffer.writeln('');
+    
+    if (oldInfo.content == null) {
+      buffer.writeln('No content information available for old file. Cannot generate diff.');
+      return buffer.toString();
+    }
+    
+    final oldBytes = oldInfo.content!;
+    
+    final file = File(filePath);
+    final fileStream = file.openRead(0, oldBytes.length < fileSize ? oldBytes.length : fileSize);
+    
+    List<int> newBytes = [];
+    await for (var chunk in fileStream) {
+      newBytes.addAll(chunk);
+    }
+    
+    if (newBytes.isNotEmpty) {
+      final newData = Uint8List.fromList(newBytes);
+      
+      buffer.writeln('=== Detailed Binary Diff (${_formatSize(newData.length < oldBytes.length ? newData.length : oldBytes.length)}) ===');
+      buffer.write(await getHexDiffDump(oldBytes, newData));
+    } else {
+      buffer.writeln('Failed to read file for comparison.');
+    }
+    
+    return buffer.toString();
+  }
+  
+  Future<Map<String, FileInfo>> _scanDirectory(String directoryPath) async {
+    final result = <String, FileInfo>{};
+    final dir = Directory(directoryPath);
+    final entities = await dir.list(recursive: true).toList();
+    
+    final normalizedSnapshotsPath = p.normalize(snapshotsPath!);
+    final normalizedFlutterAssetsPath = p.normalize(p.join(rootPath!, 'flutter_assets'));
+    
+    for (final entity in entities) {
+      if (entity is File) {
+        final normalizedPath = p.normalize(entity.path);
+        if (normalizedPath.startsWith(normalizedSnapshotsPath) || 
+            normalizedPath.startsWith(normalizedFlutterAssetsPath)) {
+          continue;
+        }
+        
+        try {
+          final relativePath = p.relative(entity.path, from: rootPath!);
+          final stat = await entity.stat();
+          
+          if (stat.size > MAX_FILE_SIZE) {
+            printV('Skipping large file: $relativePath (${_formatSize(stat.size)})');
+            continue;
+          }
+          
+          Uint8List? fileContent;
+          try {
+            fileContent = await entity.readAsBytes();
+          } catch (e) {
+            printV('Error reading file content: $e');
+          }
+          
+          result[relativePath] = FileInfo(
+            path: relativePath,
+            size: stat.size,
+            modified: stat.modified,
+            content: fileContent,
+          );
+        } catch (e) {
+          printV('Error processing file ${entity.path}: $e');
+        }
+      }
+    }
+    
+    return result;
+  }
+
+  @action
+  Future<void> loadSnapshots() async {
+    try {
+      final dir = Directory(snapshotsPath!);
+      if (!await dir.exists()) return;
+      
+      final snapshotFiles = dir.listSync().whereType<File>().where(
+        (file) => file.path.endsWith('.snapshot')
+      ).toList();
+      
+      snapshots.clear();
+      List<String> corruptedFiles = [];
+      
+      for (final file in snapshotFiles) {
+        try {
+          final content = await file.readAsString();
+          
+          Map<String, dynamic>? jsonData;
+          try {
+            jsonData = jsonDecode(content) as Map<String, dynamic>;
+          } catch (jsonError) {
+            corruptedFiles.add(file.path);
+            printV('Error parsing snapshot ${file.path}: $jsonError');
+            continue;
+          }
+          
+          if (!jsonData.containsKey('files') || 
+              !jsonData.containsKey('name') || 
+              !jsonData.containsKey('timestamp')) {
+            corruptedFiles.add(file.path);
+            printV('Invalid snapshot format in ${file.path}');
+            continue;
+          }
+          
+          try {
+            final fileInfos = Map<String, FileInfo>.from(
+              (jsonData['files'] as Map).map((key, value) => MapEntry(
+                key as String,
+                FileInfo(
+                  path: value['path'] as String,
+                  size: value['size'] as int,
+                  modified: DateTime.parse(value['modified'] as String),
+                  content: value['content'] != null ? base64Decode(value['content'] as String) : null,
+                ),
+              )),
+            );
+            
+            snapshots.add(Snapshot(
+              name: jsonData['name'] as String,
+              timestamp: DateTime.parse(jsonData['timestamp'] as String),
+              files: fileInfos,
+            ));
+          } catch (e) {
+            corruptedFiles.add(file.path);
+            printV('Error processing snapshot data ${file.path}: $e');
+          }
+        } catch (e) {
+          corruptedFiles.add(file.path);
+          printV('Error loading snapshot ${file.path}: $e');
+        }
+      }
+      
+      if (corruptedFiles.isNotEmpty) {
+        await _handleCorruptedSnapshots(corruptedFiles);
+      }
+      
+      snapshots.sort((a, b) => b.timestamp.compareTo(a.timestamp));
+    } catch (e) {
+      printV('Error loading snapshots: $e');
+    }
+  }
+
+  Future<void> _handleCorruptedSnapshots(List<String> corruptedFilePaths) async {
+    printV('Found ${corruptedFilePaths.length} corrupted snapshot files:');
+    for (final path in corruptedFilePaths) {
+      printV('  - ${p.basename(path)}');
+      
+      try {
+        final file = File(path);
+        if (await file.exists()) {
+          final newPath = '$path.corrupted';
+          await file.rename(newPath);
+          printV('    Renamed to ${p.basename(newPath)}');
+        }
+      } catch (e) {
+        printV('    Failed to rename corrupted file: $e');
+      }
+    }
+  }
+
+  @action
+  Future<void> createSnapshot(String name) async {
+    try {
+      if (rootPath == null) return;
+      
+      final timestamp = DateTime.now();
+      final files = await _scanDirectory(rootPath!);
+      
+      final snapshot = Snapshot(
+        name: name,
+        timestamp: timestamp,
+        files: files,
+      );
+      
+      final jsonData = {
+        'name': snapshot.name,
+        'timestamp': snapshot.timestamp.toIso8601String(),
+        'files': snapshot.files.map((path, fileInfo) => MapEntry(
+          path,
+          {
+            'path': fileInfo.path,
+            'size': fileInfo.size,
+            'modified': fileInfo.modified.toIso8601String(),
+            'content': fileInfo.content != null ? base64Encode(fileInfo.content!) : null,
+          },
+        )),
+      };
+      
+      final snapshotFilePath = p.join(
+        snapshotsPath!,
+        '${name.replaceAll(RegExp(r'[^\w\s-]'), '_')}_${timestamp.millisecondsSinceEpoch}.snapshot',
+      );
+      
+      final file = File(snapshotFilePath);
+      await file.writeAsString(jsonEncode(jsonData));
+      
+      await loadSnapshots();
+    } catch (e) {
+      printV('Error creating snapshot: $e');
+    }
+  }
+
+  @action
+  Future<void> compareSnapshot() async {
+    if (comparisonSnapshot == null || rootPath == null) return;
+    
+    try {
+      fileChanges.clear();
+      
+      final currentFiles = await _scanDirectory(rootPath!);
+      
+      final snapshot = comparisonSnapshot!;
+      
+      for (final entry in currentFiles.entries) {
+        final path = entry.key;
+        final current = entry.value;
+        
+        if (!snapshot.files.containsKey(path)) {
+          fileChanges.add(FileChange(
+            path: path,
+            type: ChangeType.added,
+            newFile: current,
+          ));
+        } else {
+          final old = snapshot.files[path]!;
+          
+          if (old.modified != current.modified) {
+            fileChanges.add(FileChange(
+              path: path,
+              type: ChangeType.touched,
+              oldFile: old,
+              newFile: current,
+            ));
+          } else if (old.size != current.size ||
+            !_areContentsEqual(old.content, current.content)) {
+            fileChanges.add(FileChange(
+              path: path,
+              type: ChangeType.modified,
+              oldFile: old,
+              newFile: current,
+            ));
+          }
+        }
+      }
+      
+      for (final path in snapshot.files.keys) {
+        if (!currentFiles.containsKey(path)) {
+          fileChanges.add(FileChange(
+            path: path,
+            type: ChangeType.removed,
+            oldFile: snapshot.files[path],
+          ));
+        }
+      }
+      
+      fileChanges.sort((a, b) => a.path.compareTo(b.path));
+    } catch (e) {
+      printV('Error comparing snapshot: $e');
+    }
+  }
+
+  @action
+  Future<void> deleteSnapshot(Snapshot snapshot) async {
+    try {
+      final snapshotFile = File(p.join(
+        snapshotsPath!,
+        '${snapshot.name.replaceAll(RegExp(r'[^\w\s-]'), '_')}_${snapshot.timestamp.millisecondsSinceEpoch}.snapshot',
+      ));
+      
+      if (await snapshotFile.exists()) {
+        await snapshotFile.delete();
+      }
+      
+      await loadSnapshots();
+    } catch (e) {
+      printV('Error deleting snapshot: $e');
+    }
+  }
+
+  Future<String> getFileDiff(FileChange fileChange) async {
+    if (fileChange.type == ChangeType.added) {
+      final filePath = p.join(rootPath!, fileChange.path);
+      final file = File(filePath);
+      final fileSize = await file.length();
+      
+      if (fileSize > MAX_FILE_SIZE) {
+        return 'File too large to display (${_formatSize(fileSize)}). Maximum size: ${_formatSize(MAX_FILE_SIZE)}.';
+      }
+       
+      final buffer = StringBuffer();
+      buffer.writeln('=== File Added ===');
+      buffer.writeln('Path: ${fileChange.path}');
+      buffer.writeln('Size: ${_formatSize(fileChange.newFile!.size)}');
+      buffer.writeln('Modified: ${fileChange.newFile!.modified}');
+      buffer.writeln('');
+       
+      if (fileChange.newFile!.content != null) {
+        buffer.writeln('=== Hex Dump (Added File) ===');
+        final bytes = fileChange.newFile!.content!;
+        final hexDump = _formatHexDump(bytes, false);
+        
+        final hexDumpLines = hexDump.split('\n');
+        for (final line in hexDumpLines) {
+          if (line.isNotEmpty) {
+            buffer.writeln('+ $line');
+          }
+        }
+      }
+      
+      return buffer.toString();
+    } else if (fileChange.type == ChangeType.removed) {
+      final buffer = StringBuffer();
+      buffer.writeln('=== File Removed ===');
+      buffer.writeln('Path: ${fileChange.path}');
+      buffer.writeln('Size: ${_formatSize(fileChange.oldFile!.size)}');
+      buffer.writeln('Modified: ${fileChange.oldFile!.modified}');
+      buffer.writeln('');
+       
+      if (fileChange.oldFile!.content != null) {
+        buffer.writeln('=== Hex Dump (Removed File) ===');
+        final bytes = fileChange.oldFile!.content!;
+        final hexDump = _formatHexDump(bytes, false);
+        
+        final hexDumpLines = hexDump.split('\n');
+        for (final line in hexDumpLines) {
+          if (line.isNotEmpty) {
+            buffer.writeln('- $line');
+          }
+        }
+      }
+      
+      return buffer.toString();
+    } else if (fileChange.type == ChangeType.modified) {
+      final filePath = p.join(rootPath!, fileChange.path);
+      final currentFile = File(filePath);
+      final fileSize = await currentFile.length();
+        
+      if (fileSize > MAX_FILE_SIZE) {
+        return 'File too large to diff (${_formatSize(fileSize)}). Maximum size: ${_formatSize(MAX_FILE_SIZE)}.';
+      }
+        
+      final buffer = StringBuffer();
+      buffer.writeln('=== File Modified ===');
+      buffer.writeln('Path: ${fileChange.path}');
+      buffer.writeln('');
+        
+      buffer.writeln('=== Size ===');
+      buffer.writeln('Old: ${_formatSize(fileChange.oldFile!.size)}');
+      buffer.writeln('New: ${_formatSize(fileChange.newFile!.size)}');
+      buffer.writeln('Difference: ${_formatSizeDifference(fileChange.newFile!.size - fileChange.oldFile!.size)}');
+      buffer.writeln('');
+        
+      buffer.writeln('=== Timestamps ===');
+      buffer.writeln('Old modified: ${fileChange.oldFile!.modified}');
+      buffer.writeln('New modified: ${fileChange.newFile!.modified}');
+      buffer.writeln('');
+       
+      if (fileChange.oldFile!.content != null && fileChange.newFile!.content != null) {
+        buffer.writeln('=== Binary Diff ===');
+        final diff = await getHexDiffDump(fileChange.oldFile!.content!, fileChange.newFile!.content!);
+        buffer.write(diff);
+      } else {
+        buffer.writeln('Cannot create binary diff: missing content data.');
+      }
+        
+      return buffer.toString();
+    }
+      
+    return 'No detailed information available.';
+  }
+
+  String _formatHexDump(Uint8List bytes, bool truncated) {
+    final buffer = StringBuffer();
+    
+    for (var i = 0; i < bytes.length; i += 16) {
+      // Address
+      buffer.write('${i.toRadixString(16).padLeft(8, '0')}: ');
+      
+      // Hex values
+      for (var j = 0; j < 16; j++) {
+        if (i + j < bytes.length) {
+          buffer.write('${bytes[i + j].toRadixString(16).padLeft(2, '0')} ');
+        } else {
+          buffer.write('   ');
+        }
+        if (j == 7) buffer.write(' ');
+      }
+      
+      // ASCII representation
+      buffer.write(' |');
+      for (var j = 0; j < 16; j++) {
+        if (i + j < bytes.length) {
+          final char = bytes[i + j];
+          if (char >= 32 && char <= 126) {
+            buffer.write(String.fromCharCode(char));
+          } else {
+            buffer.write('.');
+          }
+        } else {
+          buffer.write(' ');
+        }
+      }
+      buffer.write('|\n');
+    }
+    
+    if (truncated) {
+      buffer.write('\n... (file continues) ...');
+    }
+    
+    return buffer.toString();
+  }
+  
+  Future<String> getTextDiff(String oldText, String newText) async {
+    final oldLines = oldText.split('\n');
+    final newLines = newText.split('\n');
+    
+    final buffer = StringBuffer();
+    
+    // Very simple diff algorithm - can be improved with a proper diff algorithm
+    final maxLines = oldLines.length > newLines.length ? oldLines.length : newLines.length;
+    
+    for (var i = 0; i < maxLines; i++) {
+      if (i < oldLines.length && i < newLines.length) {
+        if (oldLines[i] == newLines[i]) {
+          buffer.writeln('  ${newLines[i]}');
+        } else {
+          buffer.writeln('- ${oldLines[i]}');
+          buffer.writeln('+ ${newLines[i]}');
+        }
+      } else if (i < oldLines.length) {
+        buffer.writeln('- ${oldLines[i]}');
+      } else if (i < newLines.length) {
+        buffer.writeln('+ ${newLines[i]}');
+      }
+    }
+    
+    return buffer.toString();
+  }
+  
+  String _formatSize(int sizeInBytes) {
+    if (sizeInBytes < 1024) {
+      return '$sizeInBytes B';
+    } else if (sizeInBytes < 1024 * 1024) {
+      return '${(sizeInBytes / 1024).toStringAsFixed(2)} KB';
+    } else if (sizeInBytes < 1024 * 1024 * 1024) {
+      return '${(sizeInBytes / (1024 * 1024)).toStringAsFixed(2)} MB';
+    } else if (sizeInBytes < 1024 * 1024 * 1024 * 1024) {
+      return '${(sizeInBytes / (1024 * 1024 * 1024)).toStringAsFixed(2)} GB';
+    } else {
+      return '${(sizeInBytes / (1024 * 1024 * 1024 * 1024)).toStringAsFixed(2)} TB... why?';
+    }
+  }
+  
+  String _formatSizeDifference(int diffInBytes) {
+    final prefix = diffInBytes >= 0 ? '+' : '';
+    return '$prefix${_formatSize(diffInBytes.abs())}';
+  }
+
+  bool _areContentsEqual(Uint8List? a, Uint8List? b) {
+    if (a == null && b == null) return true;
+    if (a == null || b == null) return false;
+    if (a.length != b.length) return false;
+    
+    for (var i = 0; i < a.length; i++) {
+      if (a[i] != b[i]) return false;
+    }
+    
+    return true;
+  }
+
+  @action
+  Future<bool> renameFile(String oldPath, String newPath) async {
+    try {
+      final oldFile = File(oldPath);
+      final newFile = File(newPath);
+      printV('Renaming file: $oldPath to $newPath');
+      if (await newFile.exists()) {
+        return false;
+      }
+      
+      await oldFile.rename(newFile.path);
+      printV('Renamed file: $oldPath to $newPath');
+      return true;
+    } catch (e) {
+      printV('Error renaming file: $e');
+      return false;
+    }
+  }
+
+  @action
+  Future<bool> deleteFile(String path) async {
+    try {
+      final file = File(path);
+      await file.delete();
+      return true;
+    } catch (e) {
+      printV('Error deleting file: $e');
+      return false;
+    }
+  }
+
+  @action
+  Future<bool> copyFile(String sourcePath, String destinationPath) async {
+    try {
+      final sourceFile = File(sourcePath);
+      final destinationFile = File(destinationPath);
+      
+      if (await destinationFile.exists()) {
+        return false;
+      }
+      
+      await sourceFile.copy(destinationFile.path);
+      return true;
+    } catch (e) {
+      printV('Error copying file: $e');
+      return false;
+    }
+  }
+
+  static Future<void> startMonitoring() async {
+    if (_watcher != null) {
+      return;
+    }
+    
+    isMonitoringActive = true;
+    final appDir = await getAppDir();
+    if (Platform.isAndroid) {
+      _watcher = DirectoryWatcher(appDir.parent.path); // get rid of weird app_flutter directory
+    } else {
+      _watcher = DirectoryWatcher(appDir.path);
+    }
+    
+    _watcher!.events.listen((event) {
+      if (event.path.contains('flutter_engine')) {
+        return;
+      }
+      final relativePath = event.path.replaceFirst(appDir.path, '~');
+      fileEvents.add(FileEvent(
+        timestamp: DateTime.now(),
+        event: event,
+        relativePath: relativePath,
+      ));
+    });
+  }
+
+  static void stopMonitoring() {
+    if (_watcher != null) {
+      _watcher!.events.drain();
+      _watcher = null;
+      isMonitoringActive = false;
+    }
+  }
+
+  @action
+  void clearEvents() {
+    fileEvents.clear();
+  }
+
+  static Future<bool> checkDevMonitorFileExists() async {
+    final appDir = await getAppDir();
+    final devMonitorFile = File('${appDir.path}/.dev-monitor-fs');
+    return devMonitorFile.exists();
+  }
+}
\ No newline at end of file
diff --git a/lib/view_model/dev/wallet_fuzzer.dart b/lib/view_model/dev/wallet_fuzzer.dart
new file mode 100644
index 0000000000..3e04050985
--- /dev/null
+++ b/lib/view_model/dev/wallet_fuzzer.dart
@@ -0,0 +1,660 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:math';
+import 'dart:convert';
+
+import 'package:cake_wallet/core/key_service.dart';
+import 'package:cake_wallet/core/wallet_loading_service.dart';
+import 'package:cake_wallet/di.dart';
+import 'package:cake_wallet/store/settings_store.dart';
+import 'package:cake_wallet/view_model/wallet_list/wallet_list_item.dart';
+import 'package:cake_wallet/view_model/wallet_list/wallet_list_view_model.dart';
+import 'package:cw_core/sync_status.dart';
+import 'package:cw_core/utils/print_verbose.dart';
+import 'package:cw_core/wallet_base.dart';
+import 'package:cw_core/root_dir.dart';
+import 'package:cw_core/wallet_info.dart';
+import 'package:intl/intl.dart';
+import 'package:mobx/mobx.dart';
+import 'package:path/path.dart' as p;
+import 'package:cake_wallet/core/wallet_creation_service.dart';
+import 'package:cw_core/wallet_type.dart';
+import 'package:cake_wallet/monero/monero.dart';
+import 'package:cake_wallet/bitcoin/bitcoin.dart';
+import 'package:cake_wallet/bitcoin_cash/bitcoin_cash.dart';
+import 'package:cake_wallet/ethereum/ethereum.dart';
+import 'package:cake_wallet/nano/nano.dart';
+import 'package:cake_wallet/polygon/polygon.dart';
+import 'package:cake_wallet/solana/solana.dart';
+import 'package:cake_wallet/tron/tron.dart';
+import 'package:cake_wallet/zano/zano.dart';
+import 'package:cake_wallet/decred/decred.dart';
+import 'package:cw_core/wallet_credentials.dart';
+import 'package:cw_core/pathForWallet.dart';
+import 'package:cake_wallet/entities/seed_type.dart';
+import 'package:cake_wallet/core/generate_wallet_password.dart';
+
+part 'wallet_fuzzer.g.dart';
+
+class WalletFuzzerViewModel = WalletFuzzerViewModelBase with _$WalletFuzzerViewModel;
+
+class FuzzyLogEntry {
+  final DateTime timestamp;
+  final String action;
+  final String? result;
+
+  FuzzyLogEntry({required this.timestamp, required this.action, this.result});
+
+  @override
+  String toString() {
+    final formattedTime = DateFormat('yyyy-MM-dd HH:mm:ss.SSS').format(timestamp);
+    if (result != null) {
+      return '[$formattedTime] $action - $result';
+    }
+    return '[$formattedTime] $action';
+  }
+}
+
+abstract class WalletFuzzerViewModelBase with Store {
+  WalletFuzzerViewModelBase() {
+    unawaited(_initialize());
+  }
+
+  static final DateTime appStartDate = DateTime.now();
+  
+  List<FuzzyLogEntry> logs = [];
+  
+  @observable
+  bool isRunning = false;
+  
+  @observable
+  String currentOperation = 'Idle';
+  
+  @observable
+  String currentWallet = '';
+  
+  @observable
+  int operationsCompleted = 0;
+  
+  @observable
+  int errorsEncountered = 0;
+
+  @observable
+  Map<String, int> operationStats = {
+    'loadWallet': 0,
+    'syncWallet': 0,
+    'closeWallet': 0,
+    'switchWallet': 0,
+    'restartWallet': 0,
+    'checkAndCreateWallets': 0,
+    'createWalletsForType': 0,
+    'performRandomOperation': 0,
+  };
+
+  @computed
+  String get formattedOperationStats {
+    final buffer = StringBuffer();
+    final sortedEntries = operationStats.entries.toList()
+      ..sort((a, b) => b.value.compareTo(a.value));
+    
+    for (final entry in sortedEntries) {
+      final opName = entry.key;
+      final opCount = entry.value;
+      
+      String formattedName = switch (opName) {
+        'loadWallet' => 'Load Wallet',
+        'syncWallet' => 'Sync Wallet',
+        'closeWallet' => 'Close Wallet',
+        'switchWallet' => 'Switch Wallet',
+        'restartWallet' => 'Restart Wallet',
+        'checkAndCreateWallets' => 'Create Wallets',
+        'performRandomOperation' => 'Perform Random Operation',
+        _ => opName,
+      };
+      
+      buffer.writeln('$formattedName: $opCount');
+    }
+    
+    return buffer.toString();
+  }
+
+  @observable
+  String? logFilePath;
+
+  @observable
+  Directory? logDir;
+  
+  
+  WalletLoadingService walletLoadingService = getIt.get<WalletLoadingService>();
+  WalletListViewModel walletListViewModel = getIt.get<WalletListViewModel>();
+  SettingsStore settingsStore = getIt.get<SettingsStore>();
+  KeyService keyService = getIt.get<KeyService>();
+  
+  final _random = Random();
+  Timer? _fuzzerTimer;
+  
+  static const String _fuzzyFileName = '.wallet-fuzzer';
+  static const String _lastFuzzFile = 'last_fuzz';
+  static const String _statsFile = 'fuzzer_stats';
+  
+  final allTypes = [
+    WalletType.monero,
+    WalletType.bitcoin,
+    WalletType.litecoin,
+    WalletType.ethereum,
+    WalletType.bitcoinCash,
+    WalletType.polygon,
+    WalletType.solana,
+    WalletType.tron,
+    WalletType.zano,
+  ];
+
+  Future<void> _initialize() async {
+    
+    final appDir = await getAppDir();
+    logDir = Directory(p.join(appDir.path, 'fuzzy'));
+    
+    if (!await logDir!.exists()) {
+      await logDir!.create(recursive: true);
+    }
+    
+    final formattedDate = DateFormat('yyyyMMdd_HHmmss').format(appStartDate);
+    logFilePath = p.join(logDir!.path, 'log-$formattedDate.txt');
+    
+    await _logToFile('Wallet Fuzzer initialized');
+    
+    await _loadOperationStats();
+  }
+  
+  Future<void> _loadOperationStats() async {
+    try {
+      final appDir = await getAppDir();
+      final statsFilePath = p.join(appDir.path, _statsFile);
+      final statsFile = File(statsFilePath);
+      
+      if (await statsFile.exists()) {
+        final statsJson = await statsFile.readAsString();
+        final stats = jsonDecode(statsJson) as Map<String, dynamic>;
+        
+        operationStats = stats.map((key, value) => MapEntry(key, value as int));
+        
+        await _logAction('Loaded operation statistics', 
+            result: operationStats.entries.map((e) => '${e.key}: ${e.value}').join(', '));
+      } else {
+        await _logAction('No previous operation statistics found');
+      }
+    } catch (e) {
+      await _logAction('Failed to load operation statistics', result: e.toString());
+    }
+  }
+
+  Future<void> _saveOperationStats() async {
+    try {
+      final appDir = await getAppDir();
+      final statsFilePath = p.join(appDir.path, _statsFile);
+      final statsFile = File(statsFilePath);
+      
+      final statsJson = jsonEncode(operationStats);
+      await statsFile.writeAsString(statsJson);
+    } catch (e) {
+      await _logAction('Failed to save operation statistics', result: e.toString());
+    }
+  }
+
+  Future<void> _incrementOperationStat(String operation) async {
+    if (operationStats.containsKey(operation)) {
+      operationStats[operation] = operationStats[operation]! + 1;
+    } else {
+      operationStats[operation] = 1;
+    }
+    await _saveOperationStats();
+  }
+  
+  Future<void> startFuzzing() async {
+    if (isRunning) return;
+    
+    isRunning = true;
+    await _logAction('Starting wallet fuzzer');
+    
+    await _clearLastFuzzFile();
+    
+    await _ensureEnoughWallets();
+    
+    _fuzzerTimer = Timer.periodic(Duration(seconds: 1), (_) => _performRandomOperation());
+  }
+  
+  Future<void> _createFuzzyFile() async {
+    final appDir = await getAppDir();
+    final fuzzyFile = File(p.join(appDir.path, _fuzzyFileName));
+    if (!await fuzzyFile.exists()) {
+      await fuzzyFile.create();
+      await _logAction('Created fuzzy file marker for auto-restart');
+    }
+  }
+  
+  Future<void> _removeFuzzyFile() async {
+    final appDir = await getAppDir();
+    final fuzzyFile = File(p.join(appDir.path, _fuzzyFileName));
+    if (await fuzzyFile.exists()) {
+      await fuzzyFile.delete();
+      await _logAction('Removed fuzzy file marker');
+    }
+  }
+  
+  @action
+  Future<void> stopFuzzing() async {
+    if (!isRunning) return;
+    
+    _fuzzerTimer?.cancel();
+    _fuzzerTimer = null;
+    isRunning = false;
+    
+    await _logAction('Stopping wallet fuzzer');
+  }
+  
+  Future<void> _ensureEnoughWallets() async {
+    await _logAction('Checking if we need to create wallets');
+    
+    final wallets = walletListViewModel.wallets;
+    final walletsByType = <WalletType, List<WalletListItem>>{};
+    
+    for (final wallet in wallets.where((w) => !w.isHardware)) {
+      if (!walletsByType.containsKey(wallet.type)) {
+        walletsByType[wallet.type] = [];
+      }
+      walletsByType[wallet.type]!.add(wallet);
+    }
+    
+    const MIN_WALLETS = 8;
+    for (final type in allTypes) {
+      final count = walletsByType[type]?.length ?? 0;
+      if (count < MIN_WALLETS) {
+        await _logAction('Not enough wallets of type ${type.toString()}. Have: $count, Need: $MIN_WALLETS');
+        await _createWalletsForType(type, MIN_WALLETS - count);
+      } else {
+        await _logAction('Enough wallets of type ${type.toString()}. Have: $count');
+      }
+    }
+  }
+  
+  Future<void> _createWalletsForType(WalletType type, int count) async {
+    await _incrementOperationStat('createWalletsForType');
+    await _logAction('Creating $count wallets for type ${type.toString()}');
+    final walletCreationService = getIt.get<WalletCreationService>(param1: type);
+    
+    for (int i = 0; i < count; i++) {
+      await _logAction('Creating wallet ${i+1} of $count');
+      final index = i;
+      await _createSingleWallet(type, index, count, walletCreationService);
+      await Future.delayed(Duration(milliseconds: 500));
+    }
+  }
+  
+  Future<void> _createSingleWallet(
+      WalletType type, int index, int totalCount, WalletCreationService service) async {
+    try {
+      currentOperation = 'Creating wallet of type ${type.toString()} (${index+1}/$totalCount)';
+      
+      final timestamp = DateFormat('yyyyMMddHHmmss').format(DateTime.now());
+      final randomSuffix = _random.nextInt(9999).toString().padLeft(4, '0');
+      final walletName = 'fuzzy_${type.toString().split('.').last}_${timestamp}_$randomSuffix';
+      
+      await _logAction('Creating wallet credentials', result: walletName);
+      
+      final dirPath = await pathForWalletDir(name: walletName, type: type);
+      final path = await pathForWallet(name: walletName, type: type);
+      final credentials = await _prepareCredentialsForType(type, walletName);
+      credentials.walletInfo = WalletInfo.external(
+        id: WalletBase.idFor(walletName, type),
+        name: walletName,
+        type: type,
+        isRecovery: false,
+        restoreHeight: credentials.height ?? 0,
+        date: DateTime.now(),
+        path: path,
+        dirPath: dirPath,
+        address: '',
+        showIntroCakePayCard: false,
+        derivationInfo: credentials.derivationInfo,
+        hardwareWalletType: credentials.hardwareWalletType,
+      );
+      _logAction('Creating wallet', result: walletName);
+      final wallet = await service.create(credentials, isTestnet: false);
+      _logAction('Wallet created', result: walletName);
+      await _logWalletState(wallet);
+      final node = settingsStore.getCurrentNode(wallet.type);
+      _logAction('Connecting to node', result: walletName);
+      await wallet.connectToNode(node: node);
+      _logAction('Starting sync', result: walletName);
+      await wallet.startSync();
+      await Future.delayed(Duration(seconds: 5 + _random.nextInt(25)));
+      _logAction('Stopping sync', result: walletName);
+      await wallet.stopSync();
+      _logAction('Closing wallet', result: walletName);
+      await wallet.close(shouldCleanup: true);
+      _logAction('Wallet closed', result: walletName);
+    } catch (e) {
+      errorsEncountered++;
+      await _logAction('Failed to create wallet of type ${type.toString()}', result: e.toString());
+    }
+  }
+  
+  Future<WalletCredentials> _prepareCredentialsForType(WalletType type, String name) async {
+    final password = generateWalletPassword();
+    
+    switch (type) {
+      case WalletType.monero:
+        return monero!.createMoneroNewWalletCredentials(
+          name: name,
+          language: 'English',
+          seedType: MoneroSeedType.legacy.raw,
+          passphrase: '',
+          password: password,
+        );
+      case WalletType.bitcoin:
+        return bitcoin!.createBitcoinNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.litecoin:
+        return bitcoin!.createBitcoinNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.bitcoinCash:
+        return bitcoinCash!.createBitcoinCashNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.ethereum:
+        return ethereum!.createEthereumNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.nano:
+      case WalletType.banano:
+        return nano!.createNanoNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.polygon:
+        return polygon!.createPolygonNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.solana:
+        return solana!.createSolanaNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.tron:
+        return tron!.createTronNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.zano:
+        return zano!.createZanoNewWalletCredentials(
+          name: name,
+          password: password,
+          passphrase: '',
+        );
+      case WalletType.decred:
+        return decred!.createDecredNewWalletCredentials(name: name);
+      default:
+        throw Exception('Wallet creation not yet implemented for ${type.toString()}');
+    }
+  }
+  
+  Future<void> clearLogs() async {
+    logs.clear();
+    await _logAction('Logs cleared from UI');
+  }
+  
+  @action
+  Future<void> _logAction(String action, {String? result}) async {
+    final entry = FuzzyLogEntry(
+      timestamp: DateTime.now(),
+      action: action,
+      result: result,
+    );
+    
+    logs.insert(0, entry);
+    
+    if (logs.length > 500) {
+      logs.removeLast();
+    }
+    
+    await _logToFile(entry.toString());
+  }
+  
+  Future<void> _logToFile(String message) async {
+    try {
+      final file = File(logFilePath!);
+      final sink = await file.open(mode: FileMode.append);
+      sink.writeStringSync('$message\n');
+      await sink.close();
+    } catch (e) {
+      printV('Error writing to log file: $e');
+    }
+  }
+  bool isBusy = false;
+  
+  Future<void> _performRandomOperation() async {
+    if (!isRunning) return;
+    if (isBusy) return;
+    isBusy = true;
+    final wallets = walletListViewModel.wallets;
+    if (wallets.isEmpty) {
+      await _logAction('No wallets available to test');
+      return;
+    }
+    
+    try {
+      await _incrementOperationStat('performRandomOperation');
+      final operations = [
+        _loadRandomWallet,
+        _syncRandomWallet,
+        _checkAndCreateWallets,
+      ];
+      
+      final operation = operations[_random.nextInt(operations.length)];
+      await operation();
+      operationsCompleted++;
+    } catch (e, s) {
+      errorsEncountered++;
+      await _logAction('Error performing operation', result: e.toString());
+      printV('Error: $e\nStack trace: $s');
+    } finally {
+      isBusy = false;
+    }
+  }
+  
+  Future<void> _loadRandomWallet() async {
+    await _incrementOperationStat('loadWallet');
+    
+    final wallets = walletListViewModel.wallets
+        .where((wallet) => !wallet.isHardware)
+        .toList();
+    
+    if (wallets.isEmpty) {
+      await _logAction('No non-hardware wallets available to load');
+      return;
+    }
+    
+    final walletItem = wallets[_random.nextInt(wallets.length)];
+    currentWallet = walletItem.name;
+    currentOperation = 'Loading wallet ${walletItem.name}';
+    
+    await _logAction('Loading wallet', result: walletItem.name);
+    
+    try {
+      final wallet = await walletLoadingService.load(walletItem.type, walletItem.name);
+      await _logAction('Wallet loaded successfully', result: walletItem.name);
+      
+      await _logWalletState(wallet);
+      
+      await _closeWallet(wallet);
+    } catch (e) {
+      await _logWalletStateByName(walletItem.name, e.toString().replaceAll("\n", ";"));
+
+      await _logAction('Failed to load wallet', result: '${walletItem.name}: $e');
+      throw e;
+    }
+  }
+  
+  Future<void> _syncRandomWallet() async {
+    await _incrementOperationStat('syncWallet');
+    
+    final wallets = walletListViewModel.wallets
+        .where((wallet) => !wallet.isHardware)
+        .toList();
+    
+    if (wallets.isEmpty) {
+      await _logAction('No non-hardware wallets available to sync');
+      return;
+    }
+    
+    final walletItem = wallets[_random.nextInt(wallets.length)];
+    currentWallet = walletItem.name;
+
+    currentOperation = 'Syncing wallet ${walletItem.name}';
+    
+    await _logAction('Starting sync for wallet', result: walletItem.name);
+    
+    try {
+      WalletBase wallet;
+      wallet = await walletLoadingService.load(walletItem.type, walletItem.name);
+      await _logAction("loaded wallet: ${wallet.name} as ${walletItem.name}");
+      await _logWalletState(wallet);
+      
+      final node = settingsStore.getCurrentNode(wallet.type);
+      await wallet.connectToNode(node: node);
+      
+      await wallet.startSync();
+      await _logAction('Sync started for wallet', result: walletItem.name);
+      
+      final syncDuration = Duration(seconds: 5 + _random.nextInt(5));
+      await _logAction('Syncing for ${syncDuration.inSeconds} seconds', result: walletItem.name);
+      await Future.delayed(syncDuration);
+      
+      final syncStatus = wallet.syncStatus;
+      await _logAction('Sync status', result: '${walletItem.name}: ${syncStatus.runtimeType}');
+      
+      await wallet.stopSync();
+      await _logAction('Sync stopped for wallet', result: walletItem.name);
+      
+      await _logWalletState(wallet);
+      
+      await _closeWallet(wallet);
+    } catch (e) {
+      await _logAction('Error during sync operation', result: '${walletItem.name}: $e');
+      throw e;
+    }
+  }
+  
+  Future<void> _closeWallet(WalletBase wallet) async {
+    final walletName = wallet.name;
+    await _logAction('Starting wallet close procedure', result: walletName);
+    
+    try {
+      if (wallet.syncStatus is SyncingSyncStatus) {
+        await wallet.stopSync();
+        await _logAction('Stopped sync before closing', result: walletName);
+      }
+      
+      await wallet.close(shouldCleanup: true);
+      await _logAction('Wallet closed successfully', result: walletName);
+    } catch (e) {
+      await _logAction('Error in wallet close procedure', result: '$walletName: $e');
+      throw e;
+    }
+  }
+  
+  Future<void> _checkAndCreateWallets() async {
+    await _incrementOperationStat('checkAndCreateWallets');
+    
+    currentOperation = 'Checking wallet counts and creating new ones if needed';
+    await _logAction('Performing wallet count check and creation');
+    await _ensureEnoughWallets();
+  }
+  
+  Future<void> _logWalletStateByName(String walletName, String data) async {
+    try {
+      final appDir = await getAppDir();
+      final lastFuzzFile = File(p.join(appDir.path, _lastFuzzFile));
+      
+      await lastFuzzFile.writeAsString('$walletName|$data\n', mode: FileMode.append);
+      await _logAction('Updated wallet state file');
+    } catch (e) {
+      await _logAction('Failed to update wallet state file', result: e.toString());
+    }
+  }
+
+  Future<void> _logWalletState(WalletBase wallet) async {
+    try {
+      final appDir = await getAppDir();
+      final walletInfo = _getWalletStateInfo(wallet);
+      final lastFuzzFile = File(p.join(appDir.path, _lastFuzzFile));
+      
+      await lastFuzzFile.writeAsString('$walletInfo\n', mode: FileMode.append);
+      await _logAction('Updated wallet state file', result: walletInfo);
+    } catch (e) {
+      await _logAction('Failed to update wallet state file', result: e.toString());
+    }
+  }
+  
+  String _getWalletStateInfo(WalletBase wallet) {
+    String seed = wallet.seed??'noseed';
+    String keys = "";
+    try {
+      keys = wallet.keys.toString();
+    } catch (e) {
+      keys = 'nokeys$e';
+    }
+    final data = '${wallet.name}|${wallet.type}|${seed}|${keys}'.replaceAll("\n", ";");
+    return data;
+  }
+  
+  Future<void> _clearLastFuzzFile() async {
+    try {
+      final appDir = await getAppDir();
+      final lastFuzzFile = File(p.join(appDir.path, _lastFuzzFile));
+      
+      if (await lastFuzzFile.exists()) {
+        await lastFuzzFile.writeAsString('');
+        await _logAction('Cleared last_fuzz file');
+      }
+    } catch (e) {
+      await _logAction('Failed to clear last_fuzz file', result: e.toString());
+    }
+  }
+
+  Map<String, dynamic> getOperationStatsWithTiming() {
+    final now = DateTime.now();
+    final runDuration = now.difference(appStartDate);
+    final totalOps = operationStats.values.fold(0, (a, b) => a + b);
+    
+    double opsPerHour = 0;
+    if (runDuration.inMinutes >= 1) {
+      final runHours = runDuration.inMilliseconds / (1000 * 60 * 60);
+      opsPerHour = totalOps / runHours;
+    }
+    
+    return {
+      'stats': Map.from(operationStats),
+      'totalOperations': totalOps,
+      'runningTimeMinutes': runDuration.inMinutes,
+      'operationsPerHour': opsPerHour,
+      'startTimestamp': appStartDate.toIso8601String(),
+      'currentTimestamp': now.toIso8601String(),
+    };
+  }
+} 
\ No newline at end of file
diff --git a/scripts/android/debug/README.md b/scripts/android/debug/README.md
new file mode 100644
index 0000000000..3f0a0e5e6f
--- /dev/null
+++ b/scripts/android/debug/README.md
@@ -0,0 +1,35 @@
+# Debug scripts
+
+## `display_fuzzer_stats.sh`
+
+Displays wallet fuzzer statistics in one screen for every emulator
+
+## `record_tap.sh`
+
+Used to configure wallet_fuzzer.sh - to unlock wallet and start fuzzer (or any action we wish to test)
+
+## `wallet_fuzzer.sh`
+
+Main logic to start wallet fuzzing scripts
+
+## Extras
+
+In order to install app on all devices you can run the following command:
+
+```bash
+for device in $(adb devices | grep -w "device" | awk '{print $1}'); do
+    echo "Installing on $device..."
+    adb -s $device install -r build/app/outputs/flutter-apk/app-debug.apk
+done
+```
+
+To watch for some log message:
+
+```bash
+for device in $(adb devices | grep -w "device" | awk '{print $1}'); do
+    echo "Watching logs on $device..."
+    adb -s "$device" logcat | grep --line-buffered "WalletInfo corrupted" | sed "s/^/[$device] /" &
+done
+
+wait
+```
\ No newline at end of file
diff --git a/scripts/android/debug/display_fuzzer_stats.sh b/scripts/android/debug/display_fuzzer_stats.sh
new file mode 100755
index 0000000000..6c48b7b82f
--- /dev/null
+++ b/scripts/android/debug/display_fuzzer_stats.sh
@@ -0,0 +1,120 @@
+#!/bin/bash
+
+FUZZER_DATA_DIR="./wallet_fuzzer_data"
+
+clear_screen() {
+    clear
+}
+
+print_header() {
+    local col_width=$1
+    shift
+    
+    printf "%-${col_width}s" "OPERATION"
+    for device in "$@"; do
+        printf "| %-15s " "$(basename "$device")"
+    done
+    echo
+    
+    # Print separator line
+    printf "%${col_width}s" | tr ' ' '-'
+    for ((i=1; i<=$#; i++)); do
+        printf "%s" "+-----------------"
+    done
+    echo
+}
+
+display_stats() {
+    clear_screen
+    
+    echo "=== WALLET FUZZER STATISTICS === (refreshes every 5 seconds)"
+    echo "Last update: $(date)"
+    echo
+    
+    device_dirs=($FUZZER_DATA_DIR/*)
+    
+    if [ ${#device_dirs[@]} -eq 0 ]; then
+        echo "No device data found in $FUZZER_DATA_DIR"
+        return
+    fi
+    
+    operations=()
+    for device in "${device_dirs[@]}"; do
+        if [ -f "$device/fuzzer_stats.json" ]; then
+            if command -v jq &>/dev/null; then
+                device_ops=$(jq -r 'keys[]' "$device/fuzzer_stats.json" 2>/dev/null)
+                for op in $device_ops; do
+                    if [[ ! " ${operations[@]} " =~ " ${op} " ]]; then
+                        operations+=("$op")
+                    fi
+                done
+            fi
+        fi
+    done
+    
+    IFS=$'\n' sorted_operations=($(sort <<<"${operations[*]}"))
+    unset IFS
+    
+    col_width=20
+    for op in "${sorted_operations[@]}"; do
+        if [ ${#op} -gt $col_width ]; then
+            col_width=${#op}
+        fi
+    done
+    col_width=$((col_width + 5))
+    
+    print_header $col_width "${device_dirs[@]}"
+    
+    for op in "${sorted_operations[@]}"; do
+        printf "%-${col_width}s" "$op"
+        
+        for device in "${device_dirs[@]}"; do
+            if [ -f "$device/fuzzer_stats.json" ] && command -v jq &>/dev/null; then
+                value=$(jq -r ".[\"$op\"] // 0" "$device/fuzzer_stats.json" 2>/dev/null)
+                if [ -z "$value" ] || [ "$value" = "null" ]; then
+                    value=0
+                fi
+                printf "| %-15s " "$value"
+            else
+                printf "| %-15s " "N/A"
+            fi
+        done
+        echo
+    done
+    
+    printf "%-${col_width}s" "TOTAL"
+    grand_total=0
+    for device in "${device_dirs[@]}"; do
+        if [ -f "$device/fuzzer_stats.json" ] && command -v jq &>/dev/null; then
+            total=$(jq -r 'to_entries | map(.value) | add' "$device/fuzzer_stats.json" 2>/dev/null)
+            if [ -z "$total" ] || [ "$total" = "null" ]; then
+                total=0
+            fi
+            printf "| %-15s " "$total"
+            grand_total=$((grand_total + total))
+        else
+            printf "| %-15s " "N/A"
+        fi
+    done
+    echo
+    
+    echo
+    echo "Total operations across all devices: $grand_total"
+}
+
+main() {
+    trap 'echo "Exiting..."; exit 0' INT
+    
+    while true; do
+        display_stats
+        sleep 5
+    done
+}
+
+if ! command -v jq &>/dev/null; then
+    echo "Warning: jq is not installed. This script requires jq to parse JSON data."
+    echo "Please install jq with your package manager (e.g., apt, brew, etc.)"
+    exit 1
+fi
+
+main 
\ No newline at end of file
diff --git a/scripts/android/debug/record_tap.sh b/scripts/android/debug/record_tap.sh
new file mode 100755
index 0000000000..badaa4536c
--- /dev/null
+++ b/scripts/android/debug/record_tap.sh
@@ -0,0 +1,132 @@
+#!/bin/bash
+# This script extracts the device's screen resolution and the raw touch coordinate maximums,
+# listens for a tap event, scales the raw touch coordinates to the screen resolution,
+# and then outputs and executes an adb tap command.
+
+screen_info=$(adb shell wm size | ggrep -oP "\d+x\d+")
+if [[ -z "$screen_info" ]]; then
+  echo "Failed to get screen resolution."
+  exit 1
+fi
+
+SCREEN_WIDTH=${screen_info%x*}
+SCREEN_HEIGHT=${screen_info#*x}
+echo "Screen resolution: ${SCREEN_WIDTH}x${SCREEN_HEIGHT}"
+
+echo "Detecting touch input device..."
+TOUCH_DEVICE=""
+
+devices_info=$(adb shell getevent -i)
+echo "Found input devices:"
+
+while read -r line; do
+  if [[ $line =~ ^add\ device\ ([0-9]+):\ (.+) ]]; then
+    device_num="${BASH_REMATCH[1]}"
+    device_path="${BASH_REMATCH[2]}"
+    device_name=$(echo "$devices_info" | ggrep -A 5 "add device $device_num:" | ggrep "name:" | gawk -F'"' '{print $2}')
+    echo "  Device $device_num: $device_path ($device_name)"
+    
+    # Check if device has touch capabilities
+    # Look for ABS events 0035 and 0036 which correspond to X and Y coordinates
+    touch_info=$(adb shell getevent -pl "$device_path")
+    if echo "$touch_info" | ggrep -q "ABS.*0035" && echo "$touch_info" | ggrep -q "ABS.*0036"; then
+      TOUCH_DEVICE="$device_path"
+      echo "Selected touch device at $TOUCH_DEVICE"
+    fi
+  fi
+done < <(echo "$devices_info" | ggrep "^add device")
+
+if [[ -z "$TOUCH_DEVICE" ]]; then
+  echo "Failed to detect touch input device."
+  echo "Trying to use the first 'multi_touch' device as fallback..."
+  
+  while read -r line; do
+    if [[ $line =~ ^add\ device\ ([0-9]+):\ (.+) ]]; then
+      device_num="${BASH_REMATCH[1]}"
+      device_path="${BASH_REMATCH[2]}"
+      device_name=$(echo "$devices_info" | ggrep -A 5 "add device $device_num:" | ggrep "name:" | gawk -F'"' '{print $2}')
+      
+      if [[ "$device_name" == *"multi_touch"* ]]; then
+        TOUCH_DEVICE="$device_path"
+        echo "Selected fallback touch device at $TOUCH_DEVICE ($device_name)"
+        break
+      fi
+    fi
+  done < <(echo "$devices_info" | ggrep "^add device")
+fi
+
+if [[ -z "$TOUCH_DEVICE" ]]; then
+  echo "No touch device found. Please manually specify the device node as an argument."
+  echo "Available devices:"
+  echo "$devices_info" | ggrep -A 5 "^add device" | ggrep -E "^add device|name:"
+  exit 1
+fi
+
+raw_info=$(adb shell getevent -pl "$TOUCH_DEVICE")
+
+# Extract X and Y max values - try multiple ABS codes that could represent X/Y coordinates
+extract_max() {
+  local raw_info="$1"
+  local abs_code="$2"
+  
+  echo "$raw_info" | gawk -v code="$abs_code" '
+    $0 ~ code {
+      for(i=1; i<=NF; i++) {
+        if($i == "max") {
+          print $(i+1)
+          exit
+        }
+      }
+    }
+  '
+}
+
+# Try to find X max from either ABS_MT_POSITION_X or plain X position (0035)
+RAW_MAX_X=$(extract_max "$raw_info" "ABS_MT_POSITION_X")
+if [[ -z "$RAW_MAX_X" ]]; then
+  RAW_MAX_X=$(extract_max "$raw_info" "0035")
+fi
+
+# Try to find Y max from either ABS_MT_POSITION_Y or plain Y position (0036)
+RAW_MAX_Y=$(extract_max "$raw_info" "ABS_MT_POSITION_Y")
+if [[ -z "$RAW_MAX_Y" ]]; then
+  RAW_MAX_Y=$(extract_max "$raw_info" "0036")
+fi
+
+if [[ -z "$RAW_MAX_X" || -z "$RAW_MAX_Y" ]]; then
+  echo "Failed to extract raw maximum values for touch coordinates."
+  echo "Using default values for emulator: 32767 x 32767"
+  RAW_MAX_X=32767
+  RAW_MAX_Y=32767
+fi
+
+echo "Raw touch coordinate range: X max=$RAW_MAX_X, Y max=$RAW_MAX_Y"
+
+echo "Waiting for a tap event. Press Ctrl+C to exit..."
+
+adb shell getevent -lt "$TOUCH_DEVICE" | gawk -v sw="$SCREEN_WIDTH" -v sh="$SCREEN_HEIGHT" -v rx="$RAW_MAX_X" -v ry="$RAW_MAX_Y" '
+  /ABS_MT_POSITION_X/ || /0035 / {
+    # Convert hex raw x-coordinate to a number.
+    raw_x = strtonum("0x" $NF)
+  }
+  /ABS_MT_POSITION_Y/ || /0036 / {
+    # Convert hex raw y-coordinate to a number.
+    raw_y = strtonum("0x" $NF)
+    # Extract the timestamp from the beginning of the line (e.g., "[   43466.939179]")
+    if (match($0, /\[ *([0-9]+\.[0-9]+)\]/, arr)) {
+       curr_time = arr[1] + 0  # ensure numeric conversion
+    }
+    # If a previous timestamp exists, compute delay and print sleep command.
+    if (prev_time != "") {
+       delay = curr_time - prev_time
+       # Print a sleep command with the delay (formatted with microsecond precision)
+       printf "sleep %.6f\n", delay
+    }
+    prev_time = curr_time
+    # Scale raw coordinates to screen resolution coordinates.
+    scaled_x = int(raw_x * sw / rx)
+    scaled_y = int(raw_y * sh / ry)
+    # Print the input tap command.
+    printf "adb -s \$device_id shell input tap %d %d\n", scaled_x, scaled_y
+  }
+'
diff --git a/scripts/android/debug/wallet_fuzzer.sh b/scripts/android/debug/wallet_fuzzer.sh
new file mode 100755
index 0000000000..83e4209fd3
--- /dev/null
+++ b/scripts/android/debug/wallet_fuzzer.sh
@@ -0,0 +1,421 @@
+#!/bin/bash
+set -e
+APP_PACKAGE="com.cakewallet.cake_wallet"
+ACTIVITY="com.cakewallet.cake_wallet.MainActivity"
+LAST_FUZZ_FILE="app_flutter/last_fuzz"
+STATS_FILE="app_flutter/fuzzer_stats"
+LOCAL_FUZZ_DIR="./wallet_fuzzer_data"
+
+function get_devices() {
+    adb devices | grep -v "List" | grep -v "^$" | awk '{print $1}'
+}
+
+function init_device_dirs() {
+    local device_id=$1
+    mkdir -p "$LOCAL_FUZZ_DIR/$device_id"
+}
+
+function start_app() {
+    local device_id=$1
+    adb -s $device_id shell am start -n $APP_PACKAGE/$ACTIVITY
+    echo "[$device_id] App started at $(date)"
+    # adb shell input tap <- you need to generate these commands in order to open the screen and start
+    # fuzzing.
+    # on your desktop run:
+    # ./scripts/android/debug/record_tap.sh
+    # and then copy the output into the adb shell input tap commands below.
+    # make sure to tap very briefly, otherwise multiple events will be generated.
+    sleep 6
+    adb -s $device_id shell input tap 435 1982
+    sleep 2.596161
+    adb -s $device_id shell input tap 532 1920
+    sleep 2.583818
+    adb -s $device_id shell input tap 594 1973
+    sleep 2.549104
+    adb -s $device_id shell input tap 539 2072
+    sleep 3.529221
+    adb -s $device_id shell input tap 979 139
+    sleep 3.287868
+    adb -s $device_id shell input tap 430 1645
+    sleep 2.325175
+    adb -s $device_id shell input tap 368 1784
+    sleep 2.461983
+    adb -s $device_id shell input tap 442 2164
+}
+
+function stop_app() {
+    local device_id=$1
+    adb -s $device_id shell am force-stop $APP_PACKAGE
+    echo "[$device_id] App stopped at $(date)"
+}
+
+function get_operation_stats() {
+    local device_id=$1
+    local LOCAL_STATS_FILE="$LOCAL_FUZZ_DIR/$device_id/fuzzer_stats.json"
+    local LOCAL_STATS_HISTORY="$LOCAL_FUZZ_DIR/$device_id/stats_history.json"
+    
+    echo "[$device_id] Pulling operation statistics..."
+    
+    adb -s $device_id shell run-as $APP_PACKAGE cat $STATS_FILE > $LOCAL_STATS_FILE.new 2>/dev/null
+    
+    if [ ! -s "$LOCAL_STATS_FILE.new" ]; then
+        echo "[$device_id] No operation statistics found or couldn't access file."
+        return 0
+    fi
+    
+    if ! jq empty "$LOCAL_STATS_FILE.new" 2>/dev/null; then
+        echo "[$device_id] Invalid JSON data received from device"
+        cat "$LOCAL_STATS_FILE.new"
+        return 1
+    fi
+    
+    if [ ! -f "$LOCAL_STATS_FILE" ]; then
+        # First time stats collection
+        mv "$LOCAL_STATS_FILE.new" "$LOCAL_STATS_FILE"
+        echo "[$device_id] Initial operation statistics recorded:"
+        cat "$LOCAL_STATS_FILE" | jq -r 'to_entries | .[] | "\(.key): \(.value)"' 2>/dev/null || echo "Error parsing JSON, raw content: $(cat $LOCAL_STATS_FILE)"
+        
+        TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+        STATS_CONTENT=$(cat "$LOCAL_STATS_FILE")
+        echo "[{\"timestamp\": \"$TIMESTAMP\", \"stats\": $STATS_CONTENT}]" > "$LOCAL_STATS_HISTORY"
+        echo "[$device_id] Created initial stats history with timestamp"
+        return 0
+    fi
+    
+    echo "[$device_id] Operation statistics changes since last run:"
+    
+    if command -v jq >/dev/null 2>&1; then
+        if ! jq empty "$LOCAL_STATS_FILE" 2>/dev/null; then
+            echo "[$device_id] Previous stats file corrupted, creating new baseline"
+            mv "$LOCAL_STATS_FILE.new" "$LOCAL_STATS_FILE"
+            return 0
+        fi
+        
+        PREV_STATS=$(cat "$LOCAL_STATS_FILE")
+        NEW_STATS=$(cat "$LOCAL_STATS_FILE.new")
+        
+        echo "[$device_id] Operation | Previous | Current | Difference"
+        echo "[$device_id] ----------|----------|---------|----------"
+        
+        ALL_OPS=$(jq -s '.[0] + .[1] | keys | .[]' "$LOCAL_STATS_FILE" "$LOCAL_STATS_FILE.new" | sort | uniq)
+        
+        for operation in $ALL_OPS; do
+            clean_op=$(echo "$operation" | sed 's/^"//;s/"$//')
+            
+            PREV_COUNT=$(jq -r ".[\"${clean_op}\"] // 0" <<< "$PREV_STATS")
+            
+            NEW_COUNT=$(jq -r ".[\"${clean_op}\"] // 0" <<< "$NEW_STATS")
+            
+            DIFF=$((NEW_COUNT - PREV_COUNT))
+            
+            printf "[$device_id] %-10s | %8d | %7d | %10d\n" "$clean_op" $PREV_COUNT $NEW_COUNT $DIFF
+        done
+        
+        TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")
+        if [ -f "$LOCAL_STATS_HISTORY" ]; then
+            if grep -q "^\[" "$LOCAL_STATS_HISTORY"; then
+                TEMP_FILE=$(mktemp)
+                jq --arg timestamp "$TIMESTAMP" --argjson stats "$NEW_STATS" \
+                    '. + [{"timestamp": $timestamp, "stats": $stats}]' "$LOCAL_STATS_HISTORY" > "$TEMP_FILE"
+                mv "$TEMP_FILE" "$LOCAL_STATS_HISTORY"
+            else
+                TEMP_FILE=$(mktemp)
+                echo "[" > "$TEMP_FILE"
+                jq --arg timestamp "$TIMESTAMP" --argjson stats "$NEW_STATS" \
+                    '{"timestamp": $timestamp, "stats": $stats}' <<< "{}" >> "$TEMP_FILE"
+                echo "]" >> "$TEMP_FILE"
+                mv "$TEMP_FILE" "$LOCAL_STATS_HISTORY"
+            fi
+        else
+            echo "[{\"timestamp\": \"$TIMESTAMP\", \"stats\": $NEW_STATS}]" > "$LOCAL_STATS_HISTORY"
+        fi
+    else
+        echo "[$device_id] jq not found. Install jq for better statistics display."
+        echo "[$device_id] Raw statistics: "
+        cat "$LOCAL_STATS_FILE.new"
+    fi
+    
+    mv "$LOCAL_STATS_FILE.new" "$LOCAL_STATS_FILE"
+    return 0
+}
+
+function display_stats_summary() {
+    local device_id=$1
+    local LOCAL_STATS_HISTORY="$LOCAL_FUZZ_DIR/$device_id/stats_history.json"
+    local LOCAL_FUZZ_HISTORY="$LOCAL_FUZZ_DIR/$device_id/fuzz_history.log"
+    
+    if [ ! -f "$LOCAL_STATS_HISTORY" ]; then
+        echo "[$device_id] No statistics history found."
+        return 0
+    fi
+    
+    if command -v jq >/dev/null 2>&1; then
+        echo "[$device_id] === Wallet Fuzzer Statistics Summary ==="
+        
+        if grep -q "^\[" "$LOCAL_STATS_HISTORY"; then
+            echo "[$device_id] History contains $(jq 'length' "$LOCAL_STATS_HISTORY") recorded sessions"
+            
+            FIRST_TS=$(jq -r '.[0].timestamp' "$LOCAL_STATS_HISTORY")
+            LAST_TS=$(jq -r '.[-1].timestamp' "$LOCAL_STATS_HISTORY")
+            echo "[$device_id] Tracking period: $FIRST_TS to $LAST_TS"
+            
+            LATEST_STATS=$(jq -r '.[-1].stats' "$LOCAL_STATS_HISTORY")
+            
+            TOTAL_OPS=$(jq -r 'to_entries | map(.value) | add' <<< "$LATEST_STATS" 2>/dev/null || echo 0)
+            if [ "$TOTAL_OPS" = "" ] || [ "$TOTAL_OPS" = "null" ]; then
+                TOTAL_OPS=0
+            fi
+            echo "[$device_id] Grand total operations: $TOTAL_OPS"
+            
+            echo "[$device_id] Total operations by type:"
+            jq -r 'to_entries | .[] | "\(.key): \(.value)"' <<< "$LATEST_STATS" | sort -k2 -nr | while read -r line; do
+                echo "[$device_id] $line"
+            done
+            
+            ENTRIES_COUNT=$(jq 'length' "$LOCAL_STATS_HISTORY")
+            if [ "$ENTRIES_COUNT" -gt 1 ]; then
+                FIRST_DATE=$(date -d "$FIRST_TS" +%s 2>/dev/null || date -j -f "%Y-%m-%d %H:%M:%S" "$FIRST_TS" +%s)
+                LAST_DATE=$(date -d "$LAST_TS" +%s 2>/dev/null || date -j -f "%Y-%m-%d %H:%M:%S" "$LAST_TS" +%s)
+                DURATION_HOURS=$(( (LAST_DATE - FIRST_DATE) / 3600 ))
+                
+                if [ "$DURATION_HOURS" -gt 0 ]; then
+                    echo "[$device_id] Operations per hour:"
+                    jq -r 'to_entries | .[] | "\(.key): \(.value)"' <<< "$LATEST_STATS" | while read -r line; do
+                        OP_NAME=$(echo $line | cut -d':' -f1)
+                        OP_COUNT=$(echo $line | cut -d':' -f2 | tr -d ' ')
+                        OPS_PER_HOUR=$(echo "scale=2; $OP_COUNT / $DURATION_HOURS" | bc)
+                        echo "[$device_id] $OP_NAME: $OPS_PER_HOUR"
+                    done
+                    
+                    TOTAL_OPS_PER_HOUR=$(echo "scale=2; $TOTAL_OPS / $DURATION_HOURS" | bc)
+                    echo "[$device_id] Total: $TOTAL_OPS_PER_HOUR ops/hour"
+                fi
+            fi
+        else
+            echo "[$device_id] History contains 1 recorded session"
+            echo "[$device_id] Stats from current session:"
+            LATEST_STATS=$(cat "$LOCAL_STATS_HISTORY")
+            
+            TOTAL_OPS=$(jq -r 'to_entries | map(.value) | add' <<< "$LATEST_STATS" 2>/dev/null || echo 0)
+            if [ "$TOTAL_OPS" = "" ] || [ "$TOTAL_OPS" = "null" ]; then
+                TOTAL_OPS=0
+            fi
+            echo "[$device_id] Grand total operations: $TOTAL_OPS"
+            
+            echo "[$device_id] Total operations by type:"
+            jq -r 'to_entries | .[] | "\(.key): \(.value)"' <<< "$LATEST_STATS" | sort -k2 -nr | while read -r line; do
+                echo "[$device_id] $line"
+            done
+        fi
+        
+        TOTAL_RUNS=$(grep -c "INITIAL" "$LOCAL_FUZZ_HISTORY" 2>/dev/null || echo 0)
+        echo "[$device_id] Total runs since tracking began: $TOTAL_RUNS"
+    else
+        echo "[$device_id] jq not installed. Install jq for statistics summary."
+    fi
+}
+
+function get_app_data() {
+    local device_id=$1
+    local LOCAL_FUZZ_FILE="$LOCAL_FUZZ_DIR/$device_id/last_fuzz"
+    local LOCAL_FUZZ_HISTORY="$LOCAL_FUZZ_DIR/$device_id/fuzz_history.log"
+    
+    APP_DATA_DIR=$(adb -s $device_id shell run-as $APP_PACKAGE pwd)
+    
+    if [ -z "$APP_DATA_DIR" ]; then
+        echo "[$device_id] Failed to get app data directory. Make sure app is in debug mode."
+        return 1
+    fi
+    
+    adb -s $device_id shell run-as $APP_PACKAGE cat $LAST_FUZZ_FILE > $LOCAL_FUZZ_FILE.new 2>/dev/null
+    
+    if [ ! -s "$LOCAL_FUZZ_FILE.new" ]; then
+        echo "[$device_id] No wallet state information found or couldn't access file."
+        return 0
+    fi
+    
+    ENTRY_COUNT=$(wc -l < "$LOCAL_FUZZ_FILE.new")
+    echo "[$device_id] Found $ENTRY_COUNT wallet state entries"
+    
+    if [ ! -f "$LOCAL_FUZZ_FILE" ]; then
+        mv "$LOCAL_FUZZ_FILE.new" "$LOCAL_FUZZ_FILE"
+        echo "[$device_id] Initial wallet state recorded with $ENTRY_COUNT entries:"
+        cat "$LOCAL_FUZZ_FILE" | while read -r line; do
+            echo "[$device_id]  - $line"
+        done
+        echo "$(date): INITIAL: $ENTRY_COUNT entries" >> $LOCAL_FUZZ_HISTORY
+        return 0
+    fi
+    
+    PREV_WALLETS=$(awk -F'|' '{print $1}' "$LOCAL_FUZZ_FILE" | sort | uniq)
+    NEW_WALLETS=$(awk -F'|' '{print $1}' "$LOCAL_FUZZ_FILE.new" | sort | uniq)
+    
+    NEW_ONLY_WALLETS=$(comm -13 <(echo "$PREV_WALLETS") <(echo "$NEW_WALLETS"))
+    if [ ! -z "$NEW_ONLY_WALLETS" ]; then
+        echo "[$device_id] New wallets detected: $NEW_ONLY_WALLETS (normal behavior)"
+        echo "[$device_id] New wallet details:"
+        for wallet in $NEW_ONLY_WALLETS; do
+            (grep "^$wallet|" "$LOCAL_FUZZ_FILE.new" || true) | while read -r line; do
+                echo "[$device_id]  - $line"
+            done
+        done
+    fi
+    
+    MISSING_WALLETS=$(comm -23 <(echo "$PREV_WALLETS") <(echo "$NEW_WALLETS"))
+    if [ ! -z "$MISSING_WALLETS" ]; then
+        echo "[$device_id] Wallets no longer present: $MISSING_WALLETS"
+        echo "$(date): MISSING_WALLETS: $MISSING_WALLETS" >> $LOCAL_FUZZ_HISTORY
+    fi
+    
+    COMMON_WALLETS=$(comm -12 <(echo "$PREV_WALLETS") <(echo "$NEW_WALLETS"))
+    
+    CORRUPTION_DETECTED=0
+    EVIDENCE_DIR="$LOCAL_FUZZ_DIR/$device_id/corruption_$(date +%Y%m%d_%H%M%S)"
+    
+    if [ ! -z "$COMMON_WALLETS" ]; then
+        echo "[$device_id] Checking common wallets for changes: $COMMON_WALLETS"
+        
+        for wallet in $COMMON_WALLETS; do
+            PREV_ENTRIES=$(grep "^$wallet|" "$LOCAL_FUZZ_FILE" || true)
+            NEW_ENTRIES=$(grep "^$wallet|" "$LOCAL_FUZZ_FILE.new" || true)
+            
+            PREV_COUNT=$(echo "$PREV_ENTRIES" | wc -l)
+            NEW_COUNT=$(echo "$NEW_ENTRIES" | wc -l)
+            
+            echo "[$device_id] Wallet $wallet: $PREV_COUNT previous entries, $NEW_COUNT new entries"
+            
+            if [ $NEW_COUNT -gt $PREV_COUNT ]; then
+                echo "[$device_id] Wallet $wallet has $((NEW_COUNT - PREV_COUNT)) new operation(s)"
+            fi
+            
+            PREV_INFO=$(echo "$PREV_ENTRIES" | tail -n1)
+            NEW_INFO=$(echo "$NEW_ENTRIES" | tail -n1)
+            
+            if [ "$PREV_INFO" = "$NEW_INFO" ]; then
+                echo "[$device_id] Wallet $wallet is unchanged"
+                continue
+            fi
+            mkdir -p "$EVIDENCE_DIR"
+            
+            echo "[$device_id] WALLET CHANGED - POTENTIAL CORRUPTION DETECTED"
+            echo "[$device_id] Wallet: $wallet" | tee -a "$EVIDENCE_DIR/corruption_details.txt"
+            echo "[$device_id] Previous: $PREV_INFO" | tee -a "$EVIDENCE_DIR/corruption_details.txt"
+            echo "[$device_id] Current:  $NEW_INFO" | tee -a "$EVIDENCE_DIR/corruption_details.txt"
+            CORRUPTION_DETECTED=1
+        done
+    fi
+    
+    if [ $CORRUPTION_DETECTED -eq 1 ]; then
+        echo "$(date): CORRUPTION_DETECTED" >> $LOCAL_FUZZ_HISTORY
+        
+        
+        cp "$LOCAL_FUZZ_FILE" "$EVIDENCE_DIR/last_fuzz.prev"
+        cp "$LOCAL_FUZZ_FILE.new" "$EVIDENCE_DIR/last_fuzz.new"
+        
+        echo "=== DETAILED COMPARISON $(date) ===" > "$EVIDENCE_DIR/comparison.txt"
+        echo "Previous file contents:" >> "$EVIDENCE_DIR/comparison.txt"
+        cat "$LOCAL_FUZZ_FILE" >> "$EVIDENCE_DIR/comparison.txt"
+        echo -e "\nNew file contents:" >> "$EVIDENCE_DIR/comparison.txt"
+        cat "$LOCAL_FUZZ_FILE.new" >> "$EVIDENCE_DIR/comparison.txt"
+        echo -e "\nDiff output:" >> "$EVIDENCE_DIR/comparison.txt"
+        diff "$LOCAL_FUZZ_FILE" "$LOCAL_FUZZ_FILE.new" >> "$EVIDENCE_DIR/comparison.txt" || true
+        
+        echo "[$device_id] Pulling all files from app package directory..."
+        APP_FILES_DIR="$EVIDENCE_DIR/app_files"
+        mkdir -p "$APP_FILES_DIR" || true
+        
+        FILE_LIST_TMP="$EVIDENCE_DIR/file_list.txt"
+        adb -s $device_id shell run-as $APP_PACKAGE "find . -type f | grep -v -E 'cache|no_backup'" > "$FILE_LIST_TMP"
+        
+        TOTAL_FILES=$(wc -l < "$FILE_LIST_TMP")
+        echo "[$device_id] Found $TOTAL_FILES files to process"
+        
+        FILE_COUNT=0
+        OLDIFS="$IFS"
+        IFS=$'\n'
+        for file_path in $(cat "$FILE_LIST_TMP"); do
+            FILE_COUNT=$((FILE_COUNT + 1))
+            echo "[$device_id] Processing file $FILE_COUNT/$TOTAL_FILES: $file_path"
+            
+            rel_dir=$(dirname "$file_path")
+            mkdir -p "$APP_FILES_DIR/$rel_dir" || true
+            
+            dest_file="$APP_FILES_DIR/$file_path"
+            adb -s $device_id shell run-as $APP_PACKAGE cat "$file_path" > "$dest_file" 2>/dev/null || echo "[$device_id] Failed to copy $file_path"
+        done
+        IFS="$OLDIFS"
+        
+        echo "[$device_id] Evidence saved to $EVIDENCE_DIR"
+    fi
+    
+    mv "$LOCAL_FUZZ_FILE.new" "$LOCAL_FUZZ_FILE"
+    
+    if [ $CORRUPTION_DETECTED -eq 1 ]; then
+        return 1
+    else
+        return 0
+    fi
+}
+
+function run_device_test() {
+    local device_id=$1
+    
+    stop_app $device_id
+    sleep 2
+    
+    display_stats_summary $device_id
+    
+    local error_detected=0
+    
+    while [ $error_detected -eq 0 ]; do
+        start_app $device_id
+        RUN_TIME=$((30 + RANDOM % 120))
+        echo "[$device_id] Will run for $RUN_TIME seconds"
+        sleep $RUN_TIME
+        
+        stop_app $device_id
+        
+        get_operation_stats $device_id
+        
+        get_app_data $device_id
+        if [ $? -ne 0 ]; then
+            echo "[$device_id] Stopping tests due to potential wallet corruption!"
+            error_detected=1
+            break
+        fi
+        
+        WAIT_TIME=$((5 + RANDOM % 15))
+        echo "[$device_id] Will wait for $WAIT_TIME seconds"
+        sleep $WAIT_TIME
+    done
+    
+    echo "[$device_id] Device testing completed"
+}
+
+mkdir -p $LOCAL_FUZZ_DIR
+
+DEVICES=$(get_devices)
+DEVICE_COUNT=$(echo "$DEVICES" | wc -l)
+
+if [ -z "$DEVICES" ]; then
+    echo "No ADB devices connected. Exiting."
+    exit 1
+fi
+
+echo "Found $DEVICE_COUNT connected device(s):"
+echo "$DEVICES" | while read device; do
+    echo "- $device"
+    init_device_dirs $device
+done
+
+for device in $DEVICES; do
+    echo "Starting tests on device $device"
+    RANDOM_DELAY=$(awk -v min=0.05 -v max=1.00 'BEGIN{srand(); print min+rand()*(max-min)}')
+    echo "[$device] Waiting for $RANDOM_DELAY seconds before starting test"
+    sleep $RANDOM_DELAY
+    run_device_test $device &
+done
+
+wait
+
+echo "All device tests completed"
\ No newline at end of file