stack_wallet/lib/services/wallets.dart

365 lines
12 KiB
Dart
Raw Normal View History

2022-08-26 08:11:35 +00:00
import 'package:flutter/foundation.dart';
import 'package:flutter_riverpod/flutter_riverpod.dart';
import 'package:stackwallet/hive/db.dart';
import 'package:stackwallet/models/node_model.dart';
import 'package:stackwallet/services/coins/coin_service.dart';
import 'package:stackwallet/services/coins/manager.dart';
import 'package:stackwallet/services/node_service.dart';
import 'package:stackwallet/services/transaction_notification_tracker.dart';
import 'package:stackwallet/services/wallets_service.dart';
import 'package:stackwallet/utilities/default_nodes.dart';
import 'package:stackwallet/utilities/enums/coin_enum.dart';
import 'package:stackwallet/utilities/enums/sync_type_enum.dart';
import 'package:stackwallet/utilities/listenable_list.dart';
import 'package:stackwallet/utilities/listenable_map.dart';
import 'package:stackwallet/utilities/logger.dart';
import 'package:stackwallet/utilities/prefs.dart';
import 'package:tuple/tuple.dart';
final ListenableList<ChangeNotifierProvider<Manager>> _nonFavorites =
ListenableList();
ListenableList<ChangeNotifierProvider<Manager>> get nonFavorites =>
_nonFavorites;
final ListenableList<ChangeNotifierProvider<Manager>> _favorites =
ListenableList();
ListenableList<ChangeNotifierProvider<Manager>> get favorites => _favorites;
class Wallets extends ChangeNotifier {
Wallets._private();
@override
dispose() {
debugPrint("Wallets dispose was called!!");
super.dispose();
}
static final Wallets _sharedInstance = Wallets._private();
static Wallets get sharedInstance => _sharedInstance;
late WalletsService walletsService;
late NodeService nodeService;
// mirrored maps for access to reading managers without using riverpod ref
static final ListenableMap<String, ChangeNotifierProvider<Manager>>
_managerProviderMap = ListenableMap();
static final ListenableMap<String, Manager> _managerMap = ListenableMap();
bool get hasWallets => _managerProviderMap.isNotEmpty;
List<ChangeNotifierProvider<Manager>> get managerProviders =>
_managerProviderMap.values.toList(growable: false);
List<Manager> get managers => _managerMap.values.toList(growable: false);
List<String> getWalletIdsFor({required Coin coin}) {
final List<String> result = [];
for (final manager in _managerMap.values) {
if (manager.coin == coin) {
result.add(manager.walletId);
}
}
return result;
}
2022-08-26 08:11:35 +00:00
Map<Coin, List<ChangeNotifierProvider<Manager>>> getManagerProvidersByCoin() {
Map<Coin, List<ChangeNotifierProvider<Manager>>> result = {};
for (final manager in _managerMap.values) {
if (result[manager.coin] == null) {
result[manager.coin] = [];
}
result[manager.coin]!.add(_managerProviderMap[manager.walletId]
as ChangeNotifierProvider<Manager>);
}
return result;
}
ChangeNotifierProvider<Manager> getManagerProvider(String walletId) {
return _managerProviderMap[walletId] as ChangeNotifierProvider<Manager>;
}
Manager getManager(String walletId) {
return _managerMap[walletId] as Manager;
}
void addWallet({required String walletId, required Manager manager}) {
_managerMap.add(walletId, manager, true);
_managerProviderMap.add(
walletId, ChangeNotifierProvider<Manager>((_) => manager), true);
if (manager.isFavorite) {
_favorites.add(
_managerProviderMap[walletId] as ChangeNotifierProvider<Manager>,
false);
} else {
_nonFavorites.add(
_managerProviderMap[walletId] as ChangeNotifierProvider<Manager>,
false);
}
notifyListeners();
}
void removeWallet({required String walletId}) {
if (_managerProviderMap[walletId] == null) {
Logging.instance.log(
"Wallets.removeWallet($walletId) failed. ManagerProvider with $walletId not found!",
level: LogLevel.Warning);
return;
}
final provider = _managerProviderMap[walletId]!;
// in both non and favorites for removal
_favorites.remove(provider, true);
_nonFavorites.remove(provider, true);
_managerProviderMap.remove(walletId, true);
_managerMap.remove(walletId, true)!.exitCurrentWallet();
notifyListeners();
}
static bool hasLoaded = false;
Future<void> _initLinearly(
List<Tuple2<Manager, bool>> tuples,
) async {
for (final tuple in tuples) {
await tuple.item1.initializeExisting();
if (tuple.item2 && !tuple.item1.shouldAutoSync) {
tuple.item1.shouldAutoSync = true;
}
}
}
static int _count = 0;
Future<void> load(Prefs prefs) async {
debugPrint("++++++++++++++ Wallets().load() called: ${++_count} times");
if (hasLoaded) {
return;
}
hasLoaded = true;
// clear out any wallet hive boxes where the wallet was deleted in previous app run
for (final walletId in DB.instance
.values<String>(boxName: DB.boxNameWalletsToDeleteOnStart)) {
await DB.instance.deleteBoxFromDisk(boxName: walletId);
}
// clear list
await DB.instance
.deleteAll<String>(boxName: DB.boxNameWalletsToDeleteOnStart);
final map = await walletsService.walletNames;
List<Future<dynamic>> walletInitFutures = [];
List<Tuple2<Manager, bool>> walletsToInitLinearly = [];
final favIdList = await walletsService.getFavoriteWalletIds();
List<String> walletIdsToEnableAutoSync = [];
bool shouldAutoSyncAll = false;
switch (prefs.syncType) {
case SyncingType.currentWalletOnly:
// do nothing as this will be set when going into a wallet from the main screen
break;
case SyncingType.selectedWalletsAtStartup:
walletIdsToEnableAutoSync.addAll(prefs.walletIdsSyncOnStartup);
break;
case SyncingType.allWalletsOnStartup:
shouldAutoSyncAll = true;
break;
}
for (final entry in map.entries) {
try {
final walletId = entry.value.walletId;
late final bool isVerified;
try {
isVerified =
await walletsService.isMnemonicVerified(walletId: walletId);
} catch (e, s) {
Logging.instance.log("$e $s", level: LogLevel.Warning);
isVerified = false;
}
2022-08-26 08:11:35 +00:00
Logging.instance.log(
"LOADING WALLET: ${entry.value.toString()} IS VERIFIED: $isVerified",
level: LogLevel.Info);
if (isVerified) {
if (_managerMap[walletId] == null &&
_managerProviderMap[walletId] == null) {
final coin = entry.value.coin;
NodeModel node = nodeService.getPrimaryNodeFor(coin: coin) ??
DefaultNodes.getNodeFor(coin);
// ElectrumXNode? node = await nodeService.getCurrentNode(coin: coin);
// folowing shouldn't be needed as the defaults get saved on init
// if (node == null) {
// node = DefaultNodes.getNodeFor(coin);
//
// // save default node
// nodeService.add(node, false);
// }
final txTracker =
TransactionNotificationTracker(walletId: walletId);
final failovers = NodeService().failoverNodesFor(coin: coin);
// load wallet
final wallet = CoinServiceAPI.from(
coin,
walletId,
entry.value.name,
node,
txTracker,
prefs,
failovers,
);
final manager = Manager(wallet);
final shouldSetAutoSync = shouldAutoSyncAll ||
walletIdsToEnableAutoSync.contains(manager.walletId);
2022-09-28 15:17:16 +00:00
if (manager.coin == Coin.monero || manager.coin == Coin.wownero) {
2022-08-26 08:11:35 +00:00
walletsToInitLinearly.add(Tuple2(manager, shouldSetAutoSync));
} else {
walletInitFutures.add(manager.initializeExisting().then((value) {
if (shouldSetAutoSync) {
manager.shouldAutoSync = true;
}
}));
}
_managerMap.add(walletId, manager, false);
final managerProvider =
ChangeNotifierProvider<Manager>((_) => manager);
_managerProviderMap.add(walletId, managerProvider, false);
final favIndex = favIdList.indexOf(walletId);
if (favIndex == -1) {
_nonFavorites.add(managerProvider, true);
} else {
// it is a favorite
if (favIndex >= _favorites.length) {
_favorites.add(managerProvider, true);
} else {
_favorites.insert(favIndex, managerProvider, true);
}
}
}
} else {
// wallet creation was not completed by user so we remove it completely
await walletsService.deleteWallet(entry.value.name, false);
}
} catch (e, s) {
Logging.instance.log("$e $s", level: LogLevel.Fatal);
continue;
}
}
if (walletInitFutures.isNotEmpty && walletsToInitLinearly.isNotEmpty) {
await Future.wait([
_initLinearly(walletsToInitLinearly),
...walletInitFutures,
]);
notifyListeners();
} else if (walletInitFutures.isNotEmpty) {
await Future.wait(walletInitFutures);
notifyListeners();
} else if (walletsToInitLinearly.isNotEmpty) {
await _initLinearly(walletsToInitLinearly);
notifyListeners();
}
}
Future<void> loadAfterStackRestore(
Prefs prefs, List<Manager> managers) async {
List<Future<dynamic>> walletInitFutures = [];
List<Tuple2<Manager, bool>> walletsToInitLinearly = [];
final favIdList = await walletsService.getFavoriteWalletIds();
List<String> walletIdsToEnableAutoSync = [];
bool shouldAutoSyncAll = false;
switch (prefs.syncType) {
case SyncingType.currentWalletOnly:
// do nothing as this will be set when going into a wallet from the main screen
break;
case SyncingType.selectedWalletsAtStartup:
walletIdsToEnableAutoSync.addAll(prefs.walletIdsSyncOnStartup);
break;
case SyncingType.allWalletsOnStartup:
shouldAutoSyncAll = true;
break;
}
for (final manager in managers) {
final walletId = manager.walletId;
final isVerified =
await walletsService.isMnemonicVerified(walletId: walletId);
debugPrint(
"LOADING RESTORED WALLET: ${manager.walletName} ${manager.walletId} IS VERIFIED: $isVerified");
if (isVerified) {
if (_managerMap[walletId] == null &&
_managerProviderMap[walletId] == null) {
final shouldSetAutoSync = shouldAutoSyncAll ||
walletIdsToEnableAutoSync.contains(manager.walletId);
2022-09-28 15:17:16 +00:00
if (manager.coin == Coin.monero || manager.coin == Coin.wownero) {
2022-08-26 08:11:35 +00:00
walletsToInitLinearly.add(Tuple2(manager, shouldSetAutoSync));
} else {
walletInitFutures.add(manager.initializeExisting().then((value) {
if (shouldSetAutoSync) {
manager.shouldAutoSync = true;
}
}));
}
_managerMap.add(walletId, manager, false);
final managerProvider =
ChangeNotifierProvider<Manager>((_) => manager);
_managerProviderMap.add(walletId, managerProvider, false);
final favIndex = favIdList.indexOf(walletId);
if (favIndex == -1) {
_nonFavorites.add(managerProvider, true);
} else {
// it is a favorite
if (favIndex >= _favorites.length) {
_favorites.add(managerProvider, true);
} else {
_favorites.insert(favIndex, managerProvider, true);
}
}
}
} else {
// wallet creation was not completed by user so we remove it completely
await walletsService.deleteWallet(manager.walletName, false);
}
}
if (walletInitFutures.isNotEmpty && walletsToInitLinearly.isNotEmpty) {
await Future.wait([
_initLinearly(walletsToInitLinearly),
...walletInitFutures,
]);
notifyListeners();
} else if (walletInitFutures.isNotEmpty) {
await Future.wait(walletInitFutures);
notifyListeners();
} else if (walletsToInitLinearly.isNotEmpty) {
await _initLinearly(walletsToInitLinearly);
notifyListeners();
}
}
}