stack_wallet/lib/services/exchange/exchange_data_loading_service.dart

360 lines
12 KiB
Dart
Raw Normal View History

import 'package:flutter/foundation.dart';
import 'package:isar/isar.dart';
2023-03-01 21:52:13 +00:00
import 'package:stackwallet/db/hive/db.dart';
2023-05-03 20:03:31 +00:00
import 'package:stackwallet/models/exchange/active_pair.dart';
import 'package:stackwallet/models/exchange/aggregate_currency.dart';
import 'package:stackwallet/models/isar/exchange_cache/currency.dart';
import 'package:stackwallet/models/isar/exchange_cache/pair.dart';
import 'package:stackwallet/services/exchange/change_now/change_now_exchange.dart';
import 'package:stackwallet/services/exchange/majestic_bank/majestic_bank_exchange.dart';
import 'package:stackwallet/services/exchange/trocador/trocador_exchange.dart';
import 'package:stackwallet/utilities/enums/exchange_rate_type_enum.dart';
2022-09-09 14:03:36 +00:00
import 'package:stackwallet/utilities/logger.dart';
import 'package:stackwallet/utilities/stack_file_system.dart';
import 'package:tuple/tuple.dart';
2022-09-09 14:03:36 +00:00
class ExchangeDataLoadingService {
ExchangeDataLoadingService._();
static final ExchangeDataLoadingService _instance =
ExchangeDataLoadingService._();
static ExchangeDataLoadingService get instance => _instance;
Isar? _isar;
Isar get isar => _isar!;
VoidCallback? onLoadingError;
VoidCallback? onLoadingComplete;
static const int cacheVersion = 1;
static int get currentCacheVersion =>
DB.instance.get<dynamic>(
boxName: DB.boxNameDBInfo,
key: "exchange_data_cache_version") as int? ??
0;
Future<void> _updateCurrentCacheVersion(int version) async {
await DB.instance.put<dynamic>(
boxName: DB.boxNameDBInfo,
key: "exchange_data_cache_version",
value: version,
);
}
Future<void> initDB() async {
if (_isar != null) return;
await _isar?.close();
_isar = await Isar.open(
[
CurrencySchema,
// PairSchema,
],
directory: (await StackFileSystem.applicationIsarDirectory()).path,
2023-02-10 23:59:05 +00:00
// inspector: kDebugMode,
inspector: false,
name: "exchange_cache",
maxSizeMiB: 64,
);
2022-09-09 14:03:36 +00:00
}
2023-05-03 20:03:31 +00:00
Future<void> setCurrenciesIfEmpty(
ActivePair? pair,
ExchangeRateType rateType,
) async {
if (pair?.send == null && pair?.receive == null) {
if (await isar.currencies.count() > 0) {
2023-05-03 20:03:31 +00:00
pair?.setSend(
await getAggregateCurrency(
"BTC",
rateType,
null,
),
notifyListeners: false,
);
2023-05-03 20:03:31 +00:00
pair?.setReceive(
await getAggregateCurrency(
"XMR",
rateType,
null,
),
notifyListeners: false,
);
}
}
}
Future<AggregateCurrency?> getAggregateCurrency(
2023-04-10 20:14:03 +00:00
String ticker,
ExchangeRateType rateType,
String? contract,
) async {
final currencies = await ExchangeDataLoadingService.instance.isar.currencies
.filter()
.group((q) => rateType == ExchangeRateType.fixed
? q
.rateTypeEqualTo(SupportedRateType.both)
.or()
.rateTypeEqualTo(SupportedRateType.fixed)
: q
.rateTypeEqualTo(SupportedRateType.both)
.or()
.rateTypeEqualTo(SupportedRateType.estimated))
.and()
.tickerEqualTo(
ticker,
caseSensitive: false,
)
2023-04-10 20:14:03 +00:00
.and()
.tokenContractEqualTo(contract)
.findAll();
final items = currencies
.map((e) => Tuple2(e.exchangeName, e))
.toList(growable: false);
return items.isNotEmpty
? AggregateCurrency(exchangeCurrencyPairs: items)
: null;
}
bool get isLoading => _locked;
bool _locked = false;
Future<void> loadAll() async {
if (!_locked) {
_locked = true;
Logging.instance.log(
"ExchangeDataLoadingService.loadAll starting...",
level: LogLevel.Info,
);
final start = DateTime.now();
try {
await Future.wait([
2023-02-05 23:50:40 +00:00
_loadChangeNowCurrencies(),
2023-02-11 00:38:39 +00:00
// _loadChangeNowFixedRatePairs(),
// _loadChangeNowEstimatedRatePairs(),
// loadSimpleswapFixedRateCurrencies(ref),
// loadSimpleswapFloatingRateCurrencies(ref),
loadMajesticBankCurrencies(),
loadTrocadorCurrencies(),
]);
2023-02-11 00:38:39 +00:00
// quicker to load available currencies on the fly for a specific base currency
// await _loadChangeNowFixedRatePairs();
// await _loadChangeNowEstimatedRatePairs();
2023-02-11 00:38:39 +00:00
Logging.instance.log(
"ExchangeDataLoadingService.loadAll finished in ${DateTime.now().difference(start).inSeconds} seconds",
level: LogLevel.Info,
);
onLoadingComplete?.call();
await _updateCurrentCacheVersion(cacheVersion);
} catch (e, s) {
Logging.instance.log(
"ExchangeDataLoadingService.loadAll failed after ${DateTime.now().difference(start).inSeconds} seconds: $e\n$s",
level: LogLevel.Error,
);
onLoadingError?.call();
2022-09-09 14:03:36 +00:00
}
_locked = false;
2022-09-09 14:03:36 +00:00
}
}
2023-02-05 23:50:40 +00:00
Future<void> _loadChangeNowCurrencies() async {
final exchange = ChangeNowExchange.instance;
2023-02-05 23:50:40 +00:00
final responseCurrencies = await exchange.getAllCurrencies(false);
if (responseCurrencies.value != null) {
2023-02-05 23:50:40 +00:00
await isar.writeTxn(() async {
final idsToDelete = await isar.currencies
.where()
.exchangeNameEqualTo(ChangeNowExchange.exchangeName)
.idProperty()
.findAll();
await isar.currencies.deleteAll(idsToDelete);
await isar.currencies.putAll(responseCurrencies.value!);
});
} else {
Logging.instance.log(
"Failed to load changeNOW currencies: ${responseCurrencies.exception?.message}",
level: LogLevel.Error);
return;
}
}
2022-09-09 14:03:36 +00:00
// Future<void> _loadChangeNowFixedRatePairs() async {
// final exchange = ChangeNowExchange.instance;
//
// final responsePairs = await compute(exchange.getAllPairs, true);
//
// if (responsePairs.value != null) {
// await isar.writeTxn(() async {
// final idsToDelete2 = await isar.pairs
// .where()
// .exchangeNameEqualTo(ChangeNowExchange.exchangeName)
// .filter()
// .rateTypeEqualTo(SupportedRateType.fixed)
// .idProperty()
// .findAll();
// await isar.pairs.deleteAll(idsToDelete2);
// await isar.pairs.putAll(responsePairs.value!);
// });
// } else {
// Logging.instance.log(
// "Failed to load changeNOW available fixed rate pairs: ${responsePairs.exception?.message}",
// level: LogLevel.Error);
// return;
// }
// }
// Future<void> _loadChangeNowEstimatedRatePairs() async {
// final exchange = ChangeNowExchange.instance;
//
// final responsePairs = await compute(exchange.getAllPairs, false);
//
// if (responsePairs.value != null) {
// await isar.writeTxn(() async {
// final idsToDelete = await isar.pairs
// .where()
// .exchangeNameEqualTo(ChangeNowExchange.exchangeName)
// .filter()
// .rateTypeEqualTo(SupportedRateType.estimated)
// .idProperty()
// .findAll();
// await isar.pairs.deleteAll(idsToDelete);
// await isar.pairs.putAll(responsePairs.value!);
// });
// } else {
// Logging.instance.log(
// "Failed to load changeNOW available floating rate pairs: ${responsePairs.exception?.message}",
// level: LogLevel.Error);
// return;
// }
// }
//
// Future<void> loadSimpleswapFloatingRateCurrencies(WidgetRef ref) async {
// final exchange = SimpleSwapExchange();
// final responseCurrencies = await exchange.getAllCurrencies(false);
//
// if (responseCurrencies.value != null) {
// ref
// .read(availableSimpleswapCurrenciesProvider)
// .updateFloatingCurrencies(responseCurrencies.value!);
//
// final responsePairs = await exchange.getAllPairs(false);
//
// if (responsePairs.value != null) {
// ref
// .read(availableSimpleswapCurrenciesProvider)
// .updateFloatingPairs(responsePairs.value!);
// } else {
// Logging.instance.log(
// "loadSimpleswapFloatingRateCurrencies: $responsePairs",
// level: LogLevel.Warning,
// );
// }
// } else {
// Logging.instance.log(
// "loadSimpleswapFloatingRateCurrencies: $responseCurrencies",
// level: LogLevel.Warning,
// );
// }
// }
//
// Future<void> loadSimpleswapFixedRateCurrencies(WidgetRef ref) async {
// final exchange = SimpleSwapExchange();
// final responseCurrencies = await exchange.getAllCurrencies(true);
//
// if (responseCurrencies.value != null) {
// ref
// .read(availableSimpleswapCurrenciesProvider)
// .updateFixedCurrencies(responseCurrencies.value!);
//
// final responsePairs = await exchange.getAllPairs(true);
//
// if (responsePairs.value != null) {
// ref
// .read(availableSimpleswapCurrenciesProvider)
// .updateFixedPairs(responsePairs.value!);
// } else {
// Logging.instance.log(
// "loadSimpleswapFixedRateCurrencies: $responsePairs",
// level: LogLevel.Warning,
// );
// }
// } else {
// Logging.instance.log(
// "loadSimpleswapFixedRateCurrencies: $responseCurrencies",
// level: LogLevel.Warning,
// );
// }
// }
Future<void> loadMajesticBankCurrencies() async {
final exchange = MajesticBankExchange.instance;
final responseCurrencies = await exchange.getAllCurrencies(false);
if (responseCurrencies.value != null) {
await isar.writeTxn(() async {
final idsToDelete = await isar.currencies
.where()
.exchangeNameEqualTo(MajesticBankExchange.exchangeName)
.idProperty()
.findAll();
await isar.currencies.deleteAll(idsToDelete);
await isar.currencies.putAll(responseCurrencies.value!);
});
} else {
Logging.instance.log(
"loadMajesticBankCurrencies: $responseCurrencies",
level: LogLevel.Warning,
);
}
}
Future<void> loadTrocadorCurrencies() async {
final exchange = TrocadorExchange.instance;
final responseCurrencies = await exchange.getAllCurrencies(false);
if (responseCurrencies.value != null) {
await isar.writeTxn(() async {
final idsToDelete = await isar.currencies
.where()
.exchangeNameEqualTo(TrocadorExchange.exchangeName)
.idProperty()
.findAll();
await isar.currencies.deleteAll(idsToDelete);
await isar.currencies.putAll(responseCurrencies.value!);
});
} else {
Logging.instance.log(
"loadTrocadorCurrencies: $responseCurrencies",
level: LogLevel.Warning,
);
}
}
// Future<void> loadMajesticBankPairs() async {
// final exchange = MajesticBankExchange.instance;
//
// final responsePairs = await exchange.getAllPairs(false);
// if (responsePairs.value != null) {
// await isar.writeTxn(() async {
// final idsToDelete2 = await isar.pairs
// .where()
// .exchangeNameEqualTo(MajesticBankExchange.exchangeName)
// .idProperty()
// .findAll();
// await isar.pairs.deleteAll(idsToDelete2);
// await isar.pairs.putAll(responsePairs.value!);
// });
// } else {
// Logging.instance.log(
// "loadMajesticBankCurrencies: $responsePairs",
// level: LogLevel.Warning,
// );
// }
// }
2022-09-09 14:03:36 +00:00
}