feat: optimize wallets.wit db file

lib/screens/login/view/init_screen.dart

@@ -51,6 +51,7 @@ class InitScreenState extends State<InitScreen> with TickerProviderStateMixin {
 
   Future<Widget> loadInitialScreen() async {
     ApiDatabase database = Locator.instance<ApiDatabase>();
+    await database.loadOptimizeDbFile();
     WalletStorage storage = await database.loadWalletsDatabase();
     if (storage.wallets.isNotEmpty) {
       // There are wallets stored

lib/shared/api_database.dart

@@ -406,4 +406,71 @@ class ApiDatabase {
       return walletStorage;
     }
   }
+
+  Future<bool> loadOptimizeDbFile() async {
+    await openDatabase();
+    await loadWalletsDatabase();
+    WalletStorage _walletStorage = walletStorage;
+    Map<String, ValueTransferInfo> allVTTs = {};
+    List<MintEntry> allMints = [];
+    List<Wallet> allWallets = [];
+    List<Account> allAccounts = [];
+    List<AccountStats> allStats = [];
+    String? _encodedKeychain = await _processIsolate(method: 'getKeychain');
+    // Wallets
+    for (int wIdx = 0; wIdx < _walletStorage.wallets.length; wIdx++) {
+      var _wallet = _walletStorage.wallets.values.elementAt(wIdx);
+      if (_wallet.masterAccountStats != null) {
+        allStats.add(_wallet.masterAccountStats!);
+      }
+      // Accounts
+      var _accounts = _wallet.allAccounts();
+      allWallets.add(_wallet);
+      for (int aIdx = 0; aIdx < _accounts.length; aIdx++) {
+        Account _account = _accounts.values.elementAt(aIdx);
+        allAccounts.add(_account);
+        // VTTs
+        for (int vIdx = 0; vIdx < _account.vtts.length; vIdx++) {
+          if (allVTTs.containsKey(_account.vtts[vIdx].txnHash) == false) {
+            allVTTs[_account.vtts[vIdx].txnHash] = _account.vtts[vIdx];
+          }
+        }
+        // Mints
+        for (int mIdx = 0; mIdx < _account.mints.length; mIdx++) {
+          allMints.add(_account.mints[mIdx]);
+        }
+      }
+    }
+
+    await deleteAllWallets();
+    await openDatabase();
+    await loadWalletsDatabase();
+
+    if (_encodedKeychain != null) {
+      await _processIsolate(
+        method: 'add',
+        params: {'type': 'keychain', 'value': _encodedKeychain},
+      );
+    }
+
+    for (int wIdx = 0; wIdx < allWallets.length; wIdx++) {
+      await addWallet(allWallets[wIdx]);
+    }
+    for (int sIdx = 0; sIdx < allStats.length; sIdx++) {
+      await addStats(allStats[sIdx]);
+    }
+    for (int aIdx = 0; aIdx < allAccounts.length; aIdx++) {
+      await addAccount(allAccounts[aIdx]);
+    }
+    for (int vIdx = 0; vIdx < allVTTs.values.length; vIdx++) {
+      ValueTransferInfo _vtt = allVTTs.values.elementAt(vIdx);
+      await addVtt(_vtt);
+    }
+    for (int mIdx = 0; mIdx < allMints.length; mIdx++) {
+      await addMint(allMints[mIdx]);
+    }
+
+    await loadWalletsDatabase();
+    return true;
+  }
 }

lib/util/storage/database/database_isolate.dart

@@ -141,6 +141,9 @@ Future<void> _addRecord(
 ) async {
   bool value;
   switch (params['type']) {
+    case 'keychain':
+      value = await dbService.setEncodedKeychain(params['value']);
+      break;
     case 'wallet':
       value = await dbService.add(Wallet.fromJson(params['value']));
       break;
@@ -247,8 +250,8 @@ Future<void> _getKeychain(
   SendPort port,
   Map<String, dynamic> params,
 ) async {
-  await dbService.getKey();
-  port.send(dbService.keyChain.keyHash);
+  String? value = await dbService.getKey();
+  port.send(value);
 }
 
 Future<void> _getVtt(

lib/util/storage/database/database_service.dart

@@ -324,10 +324,15 @@ class DatabaseService {
   }
 
   Future<String?> getKey() async {
-    if (unlocked) {
-      return keyChain.getKey(_database);
-    } else {
-      return null;
+    return keyChain.getKey(_database);
+  }
+
+  Future<bool> setEncodedKeychain(String encodedKeychain) async {
+    try {
+      bool success = await keyChain.setEncodedKey(encodedKeychain, _database);
+      return success;
+    } catch (e) {
+      return false;
     }
   }
 

lib/util/storage/database/encrypt/keychain.dart

@@ -109,4 +109,21 @@ class KeyChain {
     }
     return true;
   }
+
+  factory KeyChain.fromEncodedRecord(String encodedKey) {
+    KeyChain _keychain = KeyChain();
+    _keychain.keyHash = encodedKey;
+    return _keychain;
+  }
+
+  Future<bool> setEncodedKey(
+      String encodedKey, DatabaseClient databaseClient) async {
+    try {
+      this.keyHash = encodedKey;
+      await _store.record('keychain').add(databaseClient, encodedKey);
+    } catch (e) {
+      return false;
+    }
+    return true;
+  }
 }