cake_wallet/lib/entities/default_settings_migration.dart

565 lines
20 KiB
Dart
Raw Normal View History

import 'dart:io' show File, Platform;
2021-12-24 12:37:24 +00:00
import 'package:cake_wallet/bitcoin/bitcoin.dart';
2023-03-01 21:44:15 +00:00
import 'package:cake_wallet/entities/exchange_api_mode.dart';
2021-12-24 12:37:24 +00:00
import 'package:cw_core/pathForWallet.dart';
2021-01-15 17:41:30 +00:00
import 'package:cake_wallet/entities/secret_store_key.dart';
2020-01-04 19:31:52 +00:00
import 'package:flutter/foundation.dart';
2021-01-15 17:41:30 +00:00
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
2020-01-04 19:31:52 +00:00
import 'package:hive/hive.dart';
2023-03-01 21:44:15 +00:00
import 'package:share_plus/share_plus.dart';
2020-01-04 19:31:52 +00:00
import 'package:shared_preferences/shared_preferences.dart';
2020-09-21 11:50:26 +00:00
import 'package:cake_wallet/entities/preferences_key.dart';
2021-12-24 12:37:24 +00:00
import 'package:cw_core/wallet_type.dart';
import 'package:cw_core/node.dart';
2020-09-21 11:50:26 +00:00
import 'package:cake_wallet/entities/balance_display_mode.dart';
import 'package:cake_wallet/entities/fiat_currency.dart';
import 'package:cake_wallet/entities/node_list.dart';
2021-12-24 12:37:24 +00:00
import 'package:cake_wallet/monero/monero.dart';
2020-09-23 18:26:10 +00:00
import 'package:cake_wallet/entities/contact.dart';
import 'package:cake_wallet/entities/fs_migration.dart';
2021-12-24 12:37:24 +00:00
import 'package:cw_core/wallet_info.dart';
2020-09-23 18:26:10 +00:00
import 'package:cake_wallet/exchange/trade.dart';
2021-01-15 17:41:30 +00:00
import 'package:encrypt/encrypt.dart' as encrypt;
2022-10-12 17:09:57 +00:00
import 'package:collection/collection.dart';
2020-01-04 19:31:52 +00:00
2021-02-01 18:12:37 +00:00
const newCakeWalletMoneroUri = 'xmr-node.cakewallet.com:18081';
const cakeWalletBitcoinElectrumUri = 'electrum.cakewallet.com:50002';
const cakeWalletLitecoinElectrumUri = 'ltc-electrum.cakewallet.com:50002';
const havenDefaultNodeUri = 'nodes.havenprotocol.org:443';
const ethereumDefaultNodeUri = 'ethereum.publicnode.com';
2021-02-01 18:12:37 +00:00
2020-01-04 19:31:52 +00:00
Future defaultSettingsMigration(
2022-10-12 17:09:57 +00:00
{required int version,
required SharedPreferences sharedPreferences,
required FlutterSecureStorage secureStorage,
required Box<Node> nodes,
required Box<WalletInfo> walletInfoSource,
required Box<Trade> tradeSource,
required Box<Contact> contactSource}) async {
2020-09-23 18:26:10 +00:00
if (Platform.isIOS) {
await ios_migrate_v1(walletInfoSource, tradeSource, contactSource);
}
// check current nodes for nullability regardless of the version
await checkCurrentNodes(nodes, sharedPreferences);
2021-01-15 17:41:30 +00:00
final currentVersion = sharedPreferences
.getInt(PreferencesKey.currentDefaultSettingsMigrationVersion) ??
0;
2020-01-04 19:31:52 +00:00
if (currentVersion >= version) {
return;
}
final migrationVersionsLength = version - currentVersion;
final migrationVersions = List<int>.generate(
migrationVersionsLength, (i) => currentVersion + (i + 1));
await Future.forEach(migrationVersions, (int version) async {
try {
switch (version) {
case 1:
await sharedPreferences.setString(
2020-09-21 11:50:26 +00:00
PreferencesKey.currentFiatCurrencyKey,
2020-08-27 16:54:34 +00:00
FiatCurrency.usd.toString());
2020-07-06 20:09:03 +00:00
await sharedPreferences.setInt(
2021-01-27 13:51:51 +00:00
PreferencesKey.currentTransactionPriorityKeyLegacy,
2022-10-12 17:09:57 +00:00
monero!.getDefaultTransactionPriority().raw);
await sharedPreferences.setInt(
2020-09-21 11:50:26 +00:00
PreferencesKey.currentBalanceDisplayModeKey,
BalanceDisplayMode.availableBalance.raw);
await sharedPreferences.setBool('save_recipient_address', true);
await resetToDefault(nodes);
2020-08-27 16:54:34 +00:00
await changeMoneroCurrentNodeToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
await changeBitcoinCurrentElectrumServerToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
await changeLitecoinCurrentElectrumServerToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
await changeHavenCurrentNodeToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
break;
case 2:
await replaceNodesMigration(nodes: nodes);
await replaceDefaultNode(
sharedPreferences: sharedPreferences, nodes: nodes);
2020-07-06 20:09:03 +00:00
break;
case 3:
await updateNodeTypes(nodes: nodes);
await addBitcoinElectrumServerList(nodes: nodes);
2020-08-27 16:54:34 +00:00
break;
case 4:
await changeBitcoinCurrentElectrumServerToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
break;
2020-09-23 18:26:10 +00:00
case 5:
await addAddressesForMoneroWallets(walletInfoSource);
break;
2021-01-11 17:15:27 +00:00
case 6:
await updateDisplayModes(sharedPreferences);
break;
2021-01-15 17:41:30 +00:00
case 9:
await generateBackupPassword(secureStorage);
break;
2021-01-27 13:51:51 +00:00
case 10:
await changeTransactionPriorityAndFeeRateKeys(sharedPreferences);
break;
case 11:
await changeDefaultMoneroNode(nodes, sharedPreferences);
break;
2021-01-15 17:41:30 +00:00
2021-02-01 18:12:37 +00:00
case 12:
await checkCurrentNodes(nodes, sharedPreferences);
break;
case 13:
await resetBitcoinElectrumServer(nodes, sharedPreferences);
break;
case 15:
await addLitecoinElectrumServerList(nodes: nodes);
await changeLitecoinCurrentElectrumServerToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
await checkCurrentNodes(nodes, sharedPreferences);
2021-02-01 18:12:37 +00:00
break;
2022-03-30 15:57:04 +00:00
case 16:
await addHavenNodeList(nodes: nodes);
await changeHavenCurrentNodeToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
await checkCurrentNodes(nodes, sharedPreferences);
break;
case 17:
await changeDefaultHavenNode(nodes);
break;
case 18:
await addOnionNode(nodes);
break;
case 19:
await validateBitcoinSavedTransactionPriority(sharedPreferences);
break;
2023-01-04 14:51:23 +00:00
case 20:
2023-03-01 21:44:15 +00:00
await migrateExchangeStatus(sharedPreferences);
break;
case 21:
2023-01-04 14:51:23 +00:00
await addEthereumNodeList(nodes: nodes);
await changeEthereumCurrentNodeToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
break;
default:
break;
}
await sharedPreferences.setInt(
PreferencesKey.currentDefaultSettingsMigrationVersion, version);
} catch (e) {
print('Migration error: ${e.toString()}');
2020-01-04 19:31:52 +00:00
}
});
2020-01-04 19:31:52 +00:00
2020-01-08 12:26:34 +00:00
await sharedPreferences.setInt(
PreferencesKey.currentDefaultSettingsMigrationVersion, version);
}
Future<void> validateBitcoinSavedTransactionPriority(SharedPreferences sharedPreferences) async {
if (bitcoin == null) {
return;
}
final int? savedBitcoinPriority =
sharedPreferences.getInt(PreferencesKey.bitcoinTransactionPriority);
if (!bitcoin!.getTransactionPriorities().any((element) => element.raw == savedBitcoinPriority)) {
await sharedPreferences.setInt(
PreferencesKey.bitcoinTransactionPriority, bitcoin!.getMediumTransactionPriority().serialize());
}
}
Future<void> addOnionNode(Box<Node> nodes) async {
final onionNodeUri = "cakexmrl7bonq7ovjka5kuwuyd3f7qnkz6z6s6dmsy3uckwra7bvggyd.onion:18081";
// check if the user has this node before (added it manually)
if (nodes.values.firstWhereOrNull((element) => element.uriRaw == onionNodeUri) == null) {
await nodes.add(Node(uri: onionNodeUri, type: WalletType.monero));
}
2020-01-04 19:31:52 +00:00
}
2022-10-12 17:09:57 +00:00
Future<void> replaceNodesMigration({required Box<Node> nodes}) async {
final replaceNodes = <String, Node>{
'eu-node.cakewallet.io:18081':
2020-08-27 16:54:34 +00:00
Node(uri: 'xmr-node-eu.cakewallet.com:18081', type: WalletType.monero),
'node.cakewallet.io:18081': Node(
uri: 'xmr-node-usa-east.cakewallet.com:18081', type: WalletType.monero),
'node.xmr.ru:13666':
Node(uri: 'node.monero.net:18081', type: WalletType.monero)
};
nodes.values.forEach((Node node) async {
final nodeToReplace = replaceNodes[node.uri];
if (nodeToReplace != null) {
node.uriRaw = nodeToReplace.uriRaw;
node.login = nodeToReplace.login;
node.password = nodeToReplace.password;
await node.save();
}
});
}
2020-08-27 16:54:34 +00:00
Future<void> changeMoneroCurrentNodeToDefault(
2022-10-12 17:09:57 +00:00
{required SharedPreferences sharedPreferences,
required Box<Node> nodes}) async {
2020-08-27 16:54:34 +00:00
final node = getMoneroDefaultNode(nodes: nodes);
final nodeId = node?.key as int ?? 0; // 0 - England
await sharedPreferences.setInt(PreferencesKey.currentNodeIdKey, nodeId);
2020-08-27 16:54:34 +00:00
}
2022-10-12 17:09:57 +00:00
Node? getBitcoinDefaultElectrumServer({required Box<Node> nodes}) {
return nodes.values.firstWhereOrNull(
(Node node) => node.uriRaw == cakeWalletBitcoinElectrumUri)
?? nodes.values.firstWhereOrNull((node) => node.type == WalletType.bitcoin);
2020-08-27 16:54:34 +00:00
}
2022-10-12 17:09:57 +00:00
Node? getLitecoinDefaultElectrumServer({required Box<Node> nodes}) {
return nodes.values.firstWhereOrNull(
(Node node) => node.uriRaw == cakeWalletLitecoinElectrumUri)
?? nodes.values.firstWhereOrNull((node) => node.type == WalletType.litecoin);
}
2022-10-12 17:09:57 +00:00
Node? getHavenDefaultNode({required Box<Node> nodes}) {
return nodes.values.firstWhereOrNull(
(Node node) => node.uriRaw == havenDefaultNodeUri)
?? nodes.values.firstWhereOrNull((node) => node.type == WalletType.haven);
2022-03-30 15:57:04 +00:00
}
2023-01-04 14:51:23 +00:00
Node? getEthereumDefaultNode({required Box<Node> nodes}) {
return nodes.values.firstWhereOrNull(
(Node node) => node.uriRaw == ethereumDefaultNodeUri)
?? nodes.values.firstWhereOrNull((node) => node.type == WalletType.ethereum);
}
2022-10-12 17:09:57 +00:00
Node getMoneroDefaultNode({required Box<Node> nodes}) {
final timeZone = DateTime.now().timeZoneOffset.inHours;
2020-08-27 16:54:34 +00:00
var nodeUri = '';
2020-07-06 20:09:03 +00:00
if (timeZone >= 1) {
// Eurasia
nodeUri = 'xmr-node-eu.cakewallet.com:18081';
2020-07-06 20:09:03 +00:00
} else if (timeZone <= -4) {
// America
nodeUri = 'xmr-node-usa-east.cakewallet.com:18081';
}
2022-10-12 17:09:57 +00:00
try {
return nodes.values
.firstWhere((Node node) => node.uriRaw == nodeUri);
} catch(_) {
return nodes.values.first;
}
2020-08-27 16:54:34 +00:00
}
2020-08-27 16:54:34 +00:00
Future<void> changeBitcoinCurrentElectrumServerToDefault(
2022-10-12 17:09:57 +00:00
{required SharedPreferences sharedPreferences,
required Box<Node> nodes}) async {
2020-08-27 16:54:34 +00:00
final server = getBitcoinDefaultElectrumServer(nodes: nodes);
final serverId = server?.key as int ?? 0;
await sharedPreferences.setInt(PreferencesKey.currentBitcoinElectrumSererIdKey, serverId);
}
Future<void> changeLitecoinCurrentElectrumServerToDefault(
2022-10-12 17:09:57 +00:00
{required SharedPreferences sharedPreferences,
required Box<Node> nodes}) async {
final server = getLitecoinDefaultElectrumServer(nodes: nodes);
final serverId = server?.key as int ?? 0;
await sharedPreferences.setInt(PreferencesKey.currentLitecoinElectrumSererIdKey, serverId);
}
2022-03-30 15:57:04 +00:00
Future<void> changeHavenCurrentNodeToDefault(
2022-10-12 17:09:57 +00:00
{required SharedPreferences sharedPreferences,
required Box<Node> nodes}) async {
2022-03-30 15:57:04 +00:00
final node = getHavenDefaultNode(nodes: nodes);
final nodeId = node?.key as int ?? 0;
await sharedPreferences.setInt(PreferencesKey.currentHavenNodeIdKey, nodeId);
}
Future<void> replaceDefaultNode(
2022-10-12 17:09:57 +00:00
{required SharedPreferences sharedPreferences,
required Box<Node> nodes}) async {
const nodesForReplace = <String>[
'xmr-node-uk.cakewallet.com:18081',
'eu-node.cakewallet.io:18081',
'node.cakewallet.io:18081'
];
final currentNodeId = sharedPreferences.getInt(PreferencesKey.currentNodeIdKey);
final currentNode =
2022-10-12 17:09:57 +00:00
nodes.values.firstWhereOrNull((Node node) => node.key == currentNodeId);
final needToReplace =
2022-10-12 17:09:57 +00:00
currentNode == null ? true : nodesForReplace.contains(currentNode.uriRaw);
if (!needToReplace) {
return;
}
2020-08-27 16:54:34 +00:00
await changeMoneroCurrentNodeToDefault(
sharedPreferences: sharedPreferences, nodes: nodes);
}
2020-07-06 20:09:03 +00:00
2022-10-12 17:09:57 +00:00
Future<void> updateNodeTypes({required Box<Node> nodes}) async {
2020-07-06 20:09:03 +00:00
nodes.values.forEach((node) async {
if (node.type == null) {
node.type = WalletType.monero;
await node.save();
}
});
}
2022-10-12 17:09:57 +00:00
Future<void> addBitcoinElectrumServerList({required Box<Node> nodes}) async {
final serverList = await loadBitcoinElectrumServerList();
for (var node in serverList) {
if (nodes.values.firstWhereOrNull((element) => element.uriRaw == node.uriRaw) == null) {
await nodes.add(node);
}
}
}
2022-10-12 17:09:57 +00:00
Future<void> addLitecoinElectrumServerList({required Box<Node> nodes}) async {
final serverList = await loadLitecoinElectrumServerList();
for (var node in serverList) {
if (nodes.values.firstWhereOrNull((element) => element.uriRaw == node.uriRaw) == null) {
await nodes.add(node);
}
}
2020-07-06 20:09:03 +00:00
}
2022-10-12 17:09:57 +00:00
Future<void> addHavenNodeList({required Box<Node> nodes}) async {
2022-03-30 15:57:04 +00:00
final nodeList = await loadDefaultHavenNodes();
for (var node in nodeList) {
if (nodes.values.firstWhereOrNull((element) => element.uriRaw == node.uriRaw) == null) {
await nodes.add(node);
}
}
2022-03-30 15:57:04 +00:00
}
Future<void> addAddressesForMoneroWallets(
Box<WalletInfo> walletInfoSource) async {
final moneroWalletsInfo =
walletInfoSource.values.where((info) => info.type == WalletType.monero);
moneroWalletsInfo.forEach((info) async {
try {
final walletPath =
await pathForWallet(name: info.name, type: WalletType.monero);
final addressFilePath = '$walletPath.address.txt';
final addressFile = File(addressFilePath);
if (!addressFile.existsSync()) {
return;
}
final addressText = await addressFile.readAsString();
info.address = addressText;
await info.save();
} catch (e) {
print(e.toString());
}
});
}
2021-01-11 17:15:27 +00:00
Future<void> updateDisplayModes(SharedPreferences sharedPreferences) async {
final currentBalanceDisplayMode =
2022-10-12 17:09:57 +00:00
sharedPreferences.getInt(PreferencesKey.currentBalanceDisplayModeKey) ?? -1;
2021-01-11 17:15:27 +00:00
final balanceDisplayMode = currentBalanceDisplayMode < 2 ? 3 : 2;
2021-01-15 17:41:30 +00:00
await sharedPreferences.setInt(
PreferencesKey.currentBalanceDisplayModeKey, balanceDisplayMode);
}
Future<void> generateBackupPassword(FlutterSecureStorage secureStorage) async {
final key = generateStoreKeyFor(key: SecretStoreKey.backupPassword);
if ((await secureStorage.read(key: key))?.isNotEmpty ?? false) {
return;
}
final password = encrypt.Key.fromSecureRandom(32).base16;
await secureStorage.write(key: key, value: password);
2021-01-11 17:15:27 +00:00
}
2021-01-27 13:51:51 +00:00
Future<void> changeTransactionPriorityAndFeeRateKeys(
SharedPreferences sharedPreferences) async {
final legacyTransactionPriority = sharedPreferences
2022-10-12 17:09:57 +00:00
.getInt(PreferencesKey.currentTransactionPriorityKeyLegacy)!;
2021-01-27 13:51:51 +00:00
await sharedPreferences.setInt(
PreferencesKey.moneroTransactionPriority, legacyTransactionPriority);
await sharedPreferences.setInt(PreferencesKey.bitcoinTransactionPriority,
2022-10-12 17:09:57 +00:00
bitcoin!.getMediumTransactionPriority().serialize());
2021-01-27 13:51:51 +00:00
}
Future<void> changeDefaultMoneroNode(
Box<Node> nodeSource, SharedPreferences sharedPreferences) async {
const cakeWalletMoneroNodeUriPattern = '.cakewallet.com';
final currentMoneroNodeId =
sharedPreferences.getInt(PreferencesKey.currentNodeIdKey);
final currentMoneroNode =
nodeSource.values.firstWhere((node) => node.key == currentMoneroNodeId);
final needToReplaceCurrentMoneroNode =
currentMoneroNode.uri.toString().contains(cakeWalletMoneroNodeUriPattern);
2021-01-27 13:51:51 +00:00
nodeSource.values.forEach((node) async {
if (node.type == WalletType.monero &&
node.uri.toString().contains(cakeWalletMoneroNodeUriPattern)) {
2021-01-27 13:51:51 +00:00
await node.delete();
}
});
final newCakeWalletNode =
Node(uri: newCakeWalletMoneroUri, type: WalletType.monero);
2021-01-27 13:51:51 +00:00
await nodeSource.add(newCakeWalletNode);
if (needToReplaceCurrentMoneroNode) {
await sharedPreferences.setInt(
PreferencesKey.currentNodeIdKey, newCakeWalletNode.key as int);
2021-01-27 13:51:51 +00:00
}
}
2021-02-01 18:12:37 +00:00
Future<void> checkCurrentNodes(
Box<Node> nodeSource, SharedPreferences sharedPreferences) async {
final currentMoneroNodeId =
sharedPreferences.getInt(PreferencesKey.currentNodeIdKey);
final currentBitcoinElectrumSeverId =
sharedPreferences.getInt(PreferencesKey.currentBitcoinElectrumSererIdKey);
final currentLitecoinElectrumSeverId = sharedPreferences
.getInt(PreferencesKey.currentLitecoinElectrumSererIdKey);
2022-03-30 15:57:04 +00:00
final currentHavenNodeId = sharedPreferences
.getInt(PreferencesKey.currentHavenNodeIdKey);
2023-01-04 14:51:23 +00:00
final currentEthereumNodeId = sharedPreferences
.getInt(PreferencesKey.currentEthereumNodeIdKey);
2022-10-12 17:09:57 +00:00
final currentMoneroNode = nodeSource.values.firstWhereOrNull(
(node) => node.key == currentMoneroNodeId);
final currentBitcoinElectrumServer = nodeSource.values.firstWhereOrNull(
(node) => node.key == currentBitcoinElectrumSeverId);
final currentLitecoinElectrumServer = nodeSource.values.firstWhereOrNull(
(node) => node.key == currentLitecoinElectrumSeverId);
final currentHavenNodeServer = nodeSource.values.firstWhereOrNull(
(node) => node.key == currentHavenNodeId);
2023-01-04 14:51:23 +00:00
final currentEthereumNodeServer = nodeSource.values.firstWhereOrNull(
(node) => node.key == currentEthereumNodeId);
2021-02-01 18:12:37 +00:00
if (currentMoneroNode == null) {
final newCakeWalletNode =
Node(uri: newCakeWalletMoneroUri, type: WalletType.monero);
2021-02-01 18:12:37 +00:00
await nodeSource.add(newCakeWalletNode);
await sharedPreferences.setInt(
PreferencesKey.currentNodeIdKey, newCakeWalletNode.key as int);
2021-02-01 18:12:37 +00:00
}
if (currentBitcoinElectrumServer == null) {
final cakeWalletElectrum =
Node(uri: cakeWalletBitcoinElectrumUri, type: WalletType.bitcoin);
2021-02-01 18:12:37 +00:00
await nodeSource.add(cakeWalletElectrum);
await sharedPreferences.setInt(
PreferencesKey.currentBitcoinElectrumSererIdKey,
cakeWalletElectrum.key as int);
2021-02-01 18:12:37 +00:00
}
if (currentLitecoinElectrumServer == null) {
final cakeWalletElectrum =
Node(uri: cakeWalletLitecoinElectrumUri, type: WalletType.litecoin);
await nodeSource.add(cakeWalletElectrum);
await sharedPreferences.setInt(
PreferencesKey.currentLitecoinElectrumSererIdKey,
cakeWalletElectrum.key as int);
}
2022-03-30 15:57:04 +00:00
if (currentHavenNodeServer == null) {
final node = Node(uri: havenDefaultNodeUri, type: WalletType.haven);
2022-03-30 15:57:04 +00:00
await nodeSource.add(node);
await sharedPreferences.setInt(
PreferencesKey.currentHavenNodeIdKey, node.key as int);
}
2023-01-04 14:51:23 +00:00
if (currentEthereumNodeServer == null) {
final node = Node(uri: ethereumDefaultNodeUri, type: WalletType.ethereum);
await nodeSource.add(node);
await sharedPreferences.setInt(
PreferencesKey.currentEthereumNodeIdKey, node.key as int);
}
}
2021-02-01 18:12:37 +00:00
Future<void> resetBitcoinElectrumServer(
Box<Node> nodeSource, SharedPreferences sharedPreferences) async {
final currentElectrumSeverId =
sharedPreferences.getInt(PreferencesKey.currentBitcoinElectrumSererIdKey);
2022-10-12 17:09:57 +00:00
final oldElectrumServer = nodeSource.values.firstWhereOrNull(
(node) => node.uri.toString().contains('electrumx.cakewallet.com'));
var cakeWalletNode = nodeSource.values.firstWhereOrNull(
(node) => node.uriRaw.toString() == cakeWalletBitcoinElectrumUri);
2021-02-01 18:12:37 +00:00
if (cakeWalletNode == null) {
cakeWalletNode =
Node(uri: cakeWalletBitcoinElectrumUri, type: WalletType.bitcoin);
2021-02-01 18:12:37 +00:00
await nodeSource.add(cakeWalletNode);
}
if (currentElectrumSeverId == oldElectrumServer?.key) {
await sharedPreferences.setInt(
PreferencesKey.currentBitcoinElectrumSererIdKey,
cakeWalletNode.key as int);
2021-02-01 18:12:37 +00:00
}
await oldElectrumServer?.delete();
}
Future<void> changeDefaultHavenNode(
Box<Node> nodeSource) async {
const previousHavenDefaultNodeUri = 'vault.havenprotocol.org:443';
final havenNodes = nodeSource.values.where(
(node) => node.uriRaw == previousHavenDefaultNodeUri);
havenNodes.forEach((node) async {
node.uriRaw = havenDefaultNodeUri;
await node.save();
});
}
2023-01-04 14:51:23 +00:00
2023-03-01 21:44:15 +00:00
Future<void> migrateExchangeStatus(SharedPreferences sharedPreferences) async {
final isExchangeDisabled = sharedPreferences.getBool(PreferencesKey.disableExchangeKey);
if (isExchangeDisabled == null) {
return;
}
await sharedPreferences.setInt(PreferencesKey.exchangeStatusKey, isExchangeDisabled
2023-03-01 21:44:15 +00:00
? ExchangeApiMode.disabled.raw : ExchangeApiMode.enabled.raw);
await sharedPreferences.remove(PreferencesKey.disableExchangeKey);
2023-03-01 21:44:15 +00:00
}
2023-01-04 14:51:23 +00:00
Future<void> addEthereumNodeList({required Box<Node> nodes}) async {
final nodeList = await loadDefaultEthereumNodes();
for (var node in nodeList) {
if (nodes.values.firstWhereOrNull((element) => element.uriRaw == node.uriRaw) == null) {
await nodes.add(node);
}
}
}
Future<void> changeEthereumCurrentNodeToDefault(
{required SharedPreferences sharedPreferences,
required Box<Node> nodes}) async {
final node = getEthereumDefaultNode(nodes: nodes);
final nodeId = node?.key as int? ?? 0;
await sharedPreferences.setInt(PreferencesKey.currentEthereumNodeIdKey, nodeId);
}