test(wownero): add Wownero SWB round trip test

sneurlax · sneurlax · commit de7d53f0c833 · 2025-09-17T12:43:06.000-05:00
diff --git a/lib/services/testing/test_suites/wownero_integration_test_suite.dart b/lib/services/testing/test_suites/wownero_integration_test_suite.dart
@@ -9,14 +9,17 @@
  */
 
 import 'dart:async';
+import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 import 'package:compat/old_cw_core/path_for_wallet.dart' as lib_monero_compat;
 import 'package:flutter/material.dart';
 import 'package:logger/logger.dart';
 import 'package:cs_monero/cs_monero.dart' as lib_monero;
+import 'package:tuple/tuple.dart';
 import '../../../utilities/logger.dart';
 import '../../../utilities/stack_file_system.dart';
+import '../../../pages/settings_views/global_settings_view/stack_backup_views/helpers/restore_create_backup.dart';
 import '../test_suite_interface.dart';
 import '../testing_models.dart';
 
@@ -47,7 +50,9 @@ class WowneroIntegrationTestSuite implements TestSuiteInterface {
       Logging.instance.log(Level.info, "Starting Wownero integration test suite...");
 
       await _testWowneroMnemonicGeneration();
-      
+
+      await _testWowneroStackWalletBackupRoundTrip();
+
       stopwatch.stop();
       _updateStatus(TestSuiteStatus.passed);
       
@@ -198,6 +203,261 @@ class WowneroIntegrationTestSuite implements TestSuiteInterface {
     }
   }
 
+  /// Tests Stack Wallet Backup round-trip functionality.
+  ///
+  /// Creates Wownero wallets with both 16-word and 25-word mnemonics, saves the mnemonics,
+  /// creates backups, restores the backups, and verifies the restored mnemonics match the originals.
+  Future<void> _testWowneroStackWalletBackupRoundTrip() async {
+    Logging.instance.log(Level.info, "Testing Stack Wallet Backup round-trip for Wownero...");
+
+    final tempDir = await StackFileSystem.applicationRootDirectory();
+    final testId = Random().nextInt(10000);
+
+    try {
+      // Test 16-word mnemonic backup.
+      await _testWowneroBackupWithSeedType(
+        tempDir: tempDir,
+        testId: testId,
+        seedType: lib_monero.WowneroSeedType.sixteen,
+        expectedWordCount: 16,
+        suffix: "16",
+      );
+
+      // Test 25-word mnemonic backup.
+      await _testWowneroBackupWithSeedType(
+        tempDir: tempDir,
+        testId: testId,
+        seedType: lib_monero.WowneroSeedType.twentyFive,
+        expectedWordCount: 25,
+        suffix: "25",
+      );
+
+      Logging.instance.log(Level.info, "✓ All Wownero Stack Wallet Backup round-trip tests passed successfully!");
+    } catch (e) {
+      Logging.instance.log(Level.error, "Wownero Stack Wallet Backup round-trip test failed: $e");
+      rethrow;
+    }
+  }
+
+  /// Tests Stack Wallet Backup round-trip functionality for a specific Wownero seed type.
+  Future<void> _testWowneroBackupWithSeedType({
+    required Directory tempDir,
+    required int testId,
+    required lib_monero.WowneroSeedType seedType,
+    required int expectedWordCount,
+    required String suffix,
+  }) async {
+    Logging.instance.log(Level.info, "Testing ${expectedWordCount}-word Wownero mnemonic backup...");
+
+    final walletName = "test_wownero_backup_${testId}_$suffix";
+    final walletPath = "${tempDir.path}/$walletName";
+    final backupPath = "${tempDir.path}/${walletName}_backup.swb";
+    const walletPassword = "testpass123";
+    const backupPassword = "backuppass456";
+
+    lib_monero.Wallet? originalWallet;
+    String? originalMnemonic;
+
+    try {
+      // Step 1: Create a new Wownero wallet using lib_monero directly.
+      Logging.instance.log(Level.info, "Step 1: Creating new ${expectedWordCount}-word Wownero wallet...");
+
+      originalWallet = await lib_monero.WowneroWallet.create(
+        path: walletPath,
+        password: walletPassword,
+        seedType: seedType,
+        seedOffset: "",
+      );
+
+      // Step 2: Save the original mnemonic out-of-band.
+      Logging.instance.log(Level.info, "Step 2: Saving original mnemonic...");
+      originalMnemonic = originalWallet.getSeed();
+
+      if (originalMnemonic.isEmpty) {
+        throw Exception("Failed to retrieve mnemonic from created Wownero wallet");
+      }
+
+      final originalWords = originalMnemonic.split(' ');
+      Logging.instance.log(Level.info, "Original Wownero mnemonic has ${originalWords.length} words");
+
+      // Validate the mnemonic format.
+      if (originalWords.length != expectedWordCount) {
+        throw Exception("Expected ${expectedWordCount}-word mnemonic, got ${originalWords.length} words");
+      }
+
+      // Step 3: Create a Stack Wallet Backup.
+      Logging.instance.log(Level.info, "Step 3: Creating Stack Wallet Backup...");
+
+      // Create a minimal backup JSON with just our test wallet.
+      final backupJson = {
+        "wallets": [
+          {
+            "name": walletName,
+            "id": "test_wownero_wallet_${testId}_$suffix",
+            "mnemonic": originalMnemonic,
+            "mnemonicPassphrase": "",
+            "coinName": "wownero",
+            "storedChainHeight": 0,
+            "restoreHeight": 0,
+            "notes": {},
+            "isFavorite": false,
+            "otherDataJsonString": null,
+          }
+        ],
+        "prefs": {
+          "currency": "USD",
+          "useBiometrics": false,
+          "hasPin": false,
+          "language": "en",
+          "showFavoriteWallets": true,
+          "wifiOnly": false,
+          "syncType": "allWalletsOnStartup",
+          "walletIdsSyncOnStartup": [],
+          "showTestNetCoins": false,
+          "isAutoBackupEnabled": false,
+          "autoBackupLocation": null,
+          "backupFrequencyType": "BackupFrequencyType.everyAppStart",
+          "lastAutoBackup": DateTime.now().toString(),
+        },
+        "nodes": [],
+        "addressBookEntries": [],
+        "tradeHistory": [],
+        "tradeTxidLookupData": [],
+        "tradeNotes": {},
+      };
+
+      final jsonString = jsonEncode(backupJson);
+
+      // Encrypt and save the backup.
+      final success = await SWB.encryptStackWalletWithPassphrase(
+        backupPath,
+        backupPassword,
+        jsonString,
+      );
+
+      if (!success) {
+        throw Exception("Failed to create Stack Wallet Backup for Wownero");
+      }
+
+      Logging.instance.log(Level.info, "Backup created successfully at: $backupPath");
+
+      // Step 4: Restore the Stack Wallet Backup.
+      Logging.instance.log(Level.info, "Step 4: Restoring Stack Wallet Backup...");
+
+      final restoredJsonString = await SWB.decryptStackWalletWithPassphrase(
+        Tuple2(backupPath, backupPassword),
+      );
+
+      if (restoredJsonString == null) {
+        throw Exception("Failed to decrypt Stack Wallet Backup for Wownero");
+      }
+
+      final restoredJson = jsonDecode(restoredJsonString) as Map<String, dynamic>;
+      final restoredWallets = restoredJson["wallets"] as List<dynamic>;
+
+      if (restoredWallets.isEmpty) {
+        throw Exception("No wallets found in restored Wownero backup");
+      }
+
+      final restoredWalletData = restoredWallets.first as Map<String, dynamic>;
+      final restoredMnemonic = restoredWalletData["mnemonic"] as String;
+
+      // Step 5: Verify that the restored mnemonic matches the original.
+      Logging.instance.log(Level.info, "Step 5: Verifying Wownero mnemonic integrity...");
+
+      if (restoredMnemonic != originalMnemonic) {
+        throw Exception(
+          "Wownero mnemonic mismatch!\n"
+          "Original:  $originalMnemonic\n"
+          "Restored:  $restoredMnemonic"
+        );
+      }
+
+      // Additional verification: check word count.
+      final restoredWords = restoredMnemonic.split(' ');
+
+      if (originalWords.length != restoredWords.length) {
+        throw Exception(
+          "Word count mismatch: original ${originalWords.length}, restored ${restoredWords.length}"
+        );
+      }
+
+      // Verify each word matches.
+      for (int i = 0; i < originalWords.length; i++) {
+        if (originalWords[i] != restoredWords[i]) {
+          throw Exception(
+            "Word mismatch at position $i: '${originalWords[i]}' != '${restoredWords[i]}'"
+          );
+        }
+      }
+
+      // Step 6: Additional test - verify we can recreate the wallet from the restored mnemonic.
+      Logging.instance.log(Level.info, "Step 6: Testing Wownero wallet restoration with recovered mnemonic...");
+
+      final testWalletPath = "${tempDir.path}/test_wownero_restore_${testId}_$suffix";
+      lib_monero.Wallet? restoredWallet;
+
+      try {
+        restoredWallet = await lib_monero.WowneroWallet.restoreWalletFromSeed(
+          path: testWalletPath,
+          password: walletPassword,
+          seed: restoredMnemonic,
+          restoreHeight: 0,
+          seedOffset: "",
+        );
+
+        final restoredMnemonicFromWallet = restoredWallet.getSeed();
+
+        if (restoredMnemonicFromWallet != originalMnemonic) {
+          throw Exception(
+            "Restored Wownero wallet mnemonic doesn't match original!\n"
+            "Original: $originalMnemonic\n"
+            "From restored wallet: $restoredMnemonicFromWallet"
+          );
+        }
+
+        Logging.instance.log(Level.info, "✓ Successfully restored ${expectedWordCount}-word Wownero wallet from backup mnemonic");
+
+      } finally {
+        await restoredWallet?.close();
+        // Clean up restored wallet files.
+        final testWalletFile = File(testWalletPath);
+        final testKeysFile = File("$testWalletPath.keys");
+        final testAddressFile = File("$testWalletPath.address.txt");
+
+        if (await testWalletFile.exists()) await testWalletFile.delete();
+        if (await testKeysFile.exists()) await testKeysFile.delete();
+        if (await testAddressFile.exists()) await testAddressFile.delete();
+      }
+
+      Logging.instance.log(Level.info, "✓ ${expectedWordCount}-word Wownero Stack Wallet Backup round-trip test passed!");
+      Logging.instance.log(Level.info, "✓ Original and restored Wownero mnemonics match perfectly");
+      Logging.instance.log(Level.info, "✓ Verified ${originalWords.length}-word Wownero mnemonic integrity");
+      Logging.instance.log(Level.info, "✓ Confirmed ${expectedWordCount}-word Wownero wallet can be restored from backup mnemonic");
+
+    } finally {
+      // Cleanup.
+      try {
+        await originalWallet?.close();
+
+        // Clean up test files.
+        final walletFile = File(walletPath);
+        final keysFile = File("$walletPath.keys");
+        final addressFile = File("$walletPath.address.txt");
+        final backupFile = File(backupPath);
+
+        if (await walletFile.exists()) await walletFile.delete();
+        if (await keysFile.exists()) await keysFile.delete();
+        if (await addressFile.exists()) await addressFile.delete();
+        if (await backupFile.exists()) await backupFile.delete();
+
+        Logging.instance.log(Level.info, "Cleaned up test files for ${expectedWordCount}-word Wownero backup test");
+      } catch (e) {
+        Logging.instance.log(Level.warning, "Cleanup error for ${expectedWordCount}-word Wownero test: $e");
+      }
+    }
+  }
+
   void _updateStatus(TestSuiteStatus newStatus) {
     _status = newStatus;
     _statusController.add(newStatus);
