cake_wallet/lib/monero/monero_wallet.dart

389 lines
11 KiB
Dart
Raw Normal View History

2020-11-08 20:44:09 +00:00
import 'dart:async';
import 'package:cake_wallet/monero/monero_amount_format.dart';
import 'package:cake_wallet/monero/monero_transaction_creation_exception.dart';
2020-06-20 07:10:00 +00:00
import 'package:flutter/foundation.dart';
import 'package:mobx/mobx.dart';
2020-07-06 20:09:03 +00:00
import 'package:cw_monero/wallet.dart';
import 'package:cw_monero/wallet.dart' as monero_wallet;
2020-09-21 16:56:41 +00:00
import 'package:cw_monero/transaction_history.dart' as transaction_history;
import 'package:cake_wallet/monero/monero_transaction_creation_credentials.dart';
import 'package:cake_wallet/monero/pending_monero_transaction.dart';
2020-07-06 20:09:03 +00:00
import 'package:cake_wallet/monero/monero_wallet_keys.dart';
2020-06-20 07:10:00 +00:00
import 'package:cake_wallet/monero/monero_balance.dart';
import 'package:cake_wallet/monero/monero_transaction_history.dart';
import 'package:cake_wallet/monero/monero_subaddress_list.dart';
2020-07-06 20:09:03 +00:00
import 'package:cake_wallet/monero/monero_account_list.dart';
2020-09-21 11:50:26 +00:00
import 'package:cake_wallet/monero/account.dart';
import 'package:cake_wallet/monero/subaddress.dart';
2020-08-25 16:32:40 +00:00
import 'package:cake_wallet/core/pending_transaction.dart';
2020-09-21 16:56:41 +00:00
import 'package:cake_wallet/core/wallet_base.dart';
import 'package:cake_wallet/entities/sync_status.dart';
import 'package:cake_wallet/entities/wallet_info.dart';
import 'package:cake_wallet/entities/node.dart';
2020-09-21 11:50:26 +00:00
import 'package:cake_wallet/entities/transaction_priority.dart';
2020-06-01 18:13:56 +00:00
part 'monero_wallet.g.dart';
2020-09-15 20:35:49 +00:00
const moneroBlockSize = 1000;
2020-06-01 18:13:56 +00:00
class MoneroWallet = MoneroWalletBase with _$MoneroWallet;
abstract class MoneroWalletBase extends WalletBase<MoneroBalance> with Store {
2020-09-15 20:35:49 +00:00
MoneroWalletBase({String filename, WalletInfo walletInfo})
2020-07-06 20:09:03 +00:00
: transactionHistory = MoneroTransactionHistory(),
accountList = MoneroAccountList(),
2020-09-15 20:35:49 +00:00
subaddressList = MoneroSubaddressList(),
super(walletInfo) {
2020-06-01 18:13:56 +00:00
_filename = filename;
balance = MoneroBalance(
fullBalance: monero_wallet.getFullBalance(accountIndex: 0),
unlockedBalance: monero_wallet.getFullBalance(accountIndex: 0));
2020-07-06 20:09:03 +00:00
_onAccountChangeReaction = reaction((_) => account, (Account account) {
subaddressList.update(accountIndex: account.id);
subaddress = subaddressList.subaddresses.first;
address = subaddress.address;
2020-11-04 15:54:44 +00:00
_lastAutosaveTimestamp = 0;
2020-11-09 23:14:47 +00:00
_isSavingAfterSync = false;
_isSavingAfterNewTransaction = false;
2020-07-06 20:09:03 +00:00
});
2020-06-01 18:13:56 +00:00
}
2020-11-09 23:14:47 +00:00
static const int _autoAfterSyncSaveInterval = 60000;
2020-11-04 15:54:44 +00:00
2020-06-20 07:10:00 +00:00
@override
final MoneroTransactionHistory transactionHistory;
2020-06-01 18:13:56 +00:00
@observable
Account account;
@observable
Subaddress subaddress;
2020-09-15 20:35:49 +00:00
@override
2020-06-01 18:13:56 +00:00
@observable
SyncStatus syncStatus;
@override
2020-09-15 20:35:49 +00:00
@observable
String address;
2020-06-01 18:13:56 +00:00
2020-06-20 07:10:00 +00:00
@override
@observable
2020-09-15 20:35:49 +00:00
MoneroBalance balance;
2020-06-01 18:13:56 +00:00
2020-07-06 20:09:03 +00:00
@override
String get seed => monero_wallet.getSeed();
2020-06-01 18:13:56 +00:00
2020-07-06 20:09:03 +00:00
@override
MoneroWalletKeys get keys => MoneroWalletKeys(
privateSpendKey: monero_wallet.getSecretSpendKey(),
privateViewKey: monero_wallet.getSecretViewKey(),
publicSpendKey: monero_wallet.getPublicSpendKey(),
publicViewKey: monero_wallet.getPublicViewKey());
2020-06-20 07:10:00 +00:00
2020-07-06 20:09:03 +00:00
final MoneroSubaddressList subaddressList;
2020-06-20 07:10:00 +00:00
2020-07-06 20:09:03 +00:00
final MoneroAccountList accountList;
2020-06-20 07:10:00 +00:00
2020-07-06 20:09:03 +00:00
String _filename;
2020-10-29 10:49:07 +00:00
SyncListener _listener;
2020-07-06 20:09:03 +00:00
ReactionDisposer _onAccountChangeReaction;
2020-11-04 15:54:44 +00:00
int _lastAutosaveTimestamp;
2020-11-09 23:14:47 +00:00
bool _isSavingAfterSync;
bool _isSavingAfterNewTransaction;
2020-06-01 18:13:56 +00:00
2020-06-20 07:10:00 +00:00
Future<void> init() async {
await accountList.update();
2020-07-06 20:09:03 +00:00
account = accountList.accounts.first;
2020-06-20 07:10:00 +00:00
subaddressList.update(accountIndex: account.id ?? 0);
2020-06-01 18:13:56 +00:00
subaddress = subaddressList.getAll().first;
balance = MoneroBalance(
fullBalance: monero_wallet.getFullBalance(accountIndex: account.id),
unlockedBalance:
monero_wallet.getFullBalance(accountIndex: account.id));
2020-06-20 07:10:00 +00:00
address = subaddress.address;
2020-06-01 18:13:56 +00:00
_setListeners();
await transactionHistory.update();
2020-11-04 15:54:44 +00:00
2020-10-29 10:49:07 +00:00
if (walletInfo.isRecovery) {
monero_wallet.setRecoveringFromSeed(isRecovery: walletInfo.isRecovery);
if (monero_wallet.getCurrentHeight() <= 1) {
monero_wallet.setRefreshFromBlockHeight(
height: walletInfo.restoreHeight);
}
}
2020-06-01 18:13:56 +00:00
}
void close() {
2020-06-20 07:10:00 +00:00
_listener?.stop();
2020-07-06 20:09:03 +00:00
_onAccountChangeReaction?.reaction?.dispose();
2020-06-01 18:13:56 +00:00
}
2020-10-29 10:49:07 +00:00
Future<bool> validate() async {
await accountList.update();
final accountListLength = accountList.accounts?.length ?? 0;
if (accountListLength <= 0) {
return false;
}
subaddressList.update(accountIndex: accountList.accounts.first.id);
final subaddressListLength = subaddressList.subaddresses?.length ?? 0;
if (subaddressListLength <= 0) {
return false;
}
return true;
}
2020-06-01 18:13:56 +00:00
@override
Future<void> connectToNode({@required Node node}) async {
try {
syncStatus = ConnectingSyncStatus();
await monero_wallet.setupNode(
address: node.uri,
login: node.login,
password: node.password,
useSSL: false,
// FIXME: hardcoded value
isLightWallet: false); // FIXME: hardcoded value
syncStatus = ConnectedSyncStatus();
} catch (e) {
syncStatus = FailedSyncStatus();
print(e);
}
}
@override
Future<void> startSync() async {
2020-09-15 20:35:49 +00:00
try {
_setInitialHeight();
} catch (_) {}
2020-06-01 18:13:56 +00:00
try {
syncStatus = StartingSyncStatus();
monero_wallet.startRefresh();
2020-11-04 15:54:44 +00:00
_setListeners();
_listener?.start();
2020-06-01 18:13:56 +00:00
} catch (e) {
syncStatus = FailedSyncStatus();
print(e);
rethrow;
}
}
@override
2020-08-25 16:32:40 +00:00
Future<PendingTransaction> createTransaction(Object credentials) async {
2020-09-10 14:51:59 +00:00
final _credentials = credentials as MoneroTransactionCreationCredentials;
2020-11-09 23:14:47 +00:00
final amount = _credentials.amount != null
? moneroParseAmount(amount: _credentials.amount)
: null;
2020-11-08 20:44:09 +00:00
final unlockedBalance =
monero_wallet.getUnlockedBalance(accountIndex: account.id);
2020-11-09 23:14:47 +00:00
if ((amount != null && unlockedBalance < amount) ||
(amount == null && unlockedBalance <= 0)) {
2020-11-08 20:44:09 +00:00
throw MoneroTransactionCreationException(
'Incorrect unlocked balance. Unlocked: $unlockedBalance. Transaction amount: ${_credentials.amount}.');
}
if (!(syncStatus is SyncedSyncStatus)) {
throw MoneroTransactionCreationException('The wallet is not synced.');
}
2020-09-21 16:56:41 +00:00
final pendingTransactionDescription =
await transaction_history.createTransaction(
address: _credentials.address,
paymentId: _credentials.paymentId,
amount: _credentials.amount,
priorityRaw: _credentials.priority.serialize(),
accountIndex: account.id);
return PendingMoneroTransaction(pendingTransactionDescription);
2020-06-01 18:13:56 +00:00
}
2020-08-25 16:32:40 +00:00
@override
double calculateEstimatedFee(TransactionPriority priority) {
// FIXME: hardcoded value;
if (priority == TransactionPriority.slow) {
return 0.00002459;
}
if (priority == TransactionPriority.regular) {
return 0.00012305;
}
if (priority == TransactionPriority.medium) {
return 0.00024503;
}
if (priority == TransactionPriority.fast) {
return 0.00061453;
}
if (priority == TransactionPriority.fastest) {
return 0.0260216;
}
return 0;
}
2020-06-01 18:13:56 +00:00
@override
Future<void> save() async {
2020-09-15 20:35:49 +00:00
await monero_wallet.store();
2020-06-01 18:13:56 +00:00
}
Future<int> getNodeHeight() async => monero_wallet.getNodeHeight();
Future<bool> isConnected() async => monero_wallet.isConnected();
2020-09-15 20:35:49 +00:00
Future<void> setAsRecovered() async {
walletInfo.isRecovery = false;
await walletInfo.save();
}
2020-09-21 11:50:26 +00:00
@override
Future<void> rescan({int height}) async {
2020-10-01 16:46:23 +00:00
walletInfo.restoreHeight = height;
walletInfo.isRecovery = true;
2020-09-28 19:02:30 +00:00
monero_wallet.setRefreshFromBlockHeight(height: height);
2020-09-25 15:32:44 +00:00
monero_wallet.rescanBlockchainAsync();
2020-09-28 19:02:30 +00:00
await startSync();
_askForUpdateBalance();
await _askForUpdateTransactionHistory();
await save();
2020-10-01 16:46:23 +00:00
await walletInfo.save();
2020-09-21 11:50:26 +00:00
}
2020-06-01 18:13:56 +00:00
void _setListeners() {
2020-06-20 07:10:00 +00:00
_listener?.stop();
2020-11-06 18:54:00 +00:00
_listener = monero_wallet.setListeners(_onNewBlock, _onNewTransaction);
2020-06-01 18:13:56 +00:00
}
2020-09-15 20:35:49 +00:00
void _setInitialHeight() {
if (walletInfo.isRecovery) {
return;
}
final currentHeight = getCurrentHeight();
if (currentHeight <= 1) {
final height = _getHeightByDate(walletInfo.date);
monero_wallet.setRecoveringFromSeed(isRecovery: true);
monero_wallet.setRefreshFromBlockHeight(height: height);
}
}
int _getHeightDistance(DateTime date) {
final distance =
DateTime.now().millisecondsSinceEpoch - date.millisecondsSinceEpoch;
final daysTmp = (distance / 86400).round();
final days = daysTmp < 1 ? 1 : daysTmp;
return days * 1000;
}
int _getHeightByDate(DateTime date) {
final nodeHeight = monero_wallet.getNodeHeightSync();
final heightDistance = _getHeightDistance(date);
if (nodeHeight <= 0) {
return 0;
}
return nodeHeight - heightDistance;
}
2020-06-01 18:13:56 +00:00
void _askForUpdateBalance() {
final unlockedBalance = _getUnlockedBalance();
2020-11-09 23:14:47 +00:00
final fullBalance = _getFullBalance();
2020-06-01 18:13:56 +00:00
if (balance.fullBalance != fullBalance ||
balance.unlockedBalance != unlockedBalance) {
balance = MoneroBalance(
fullBalance: fullBalance, unlockedBalance: unlockedBalance);
}
}
Future<void> _askForUpdateTransactionHistory() async {
await transactionHistory.update();
}
2020-06-01 18:13:56 +00:00
int _getFullBalance() =>
monero_wallet.getFullBalance(accountIndex: account.id);
int _getUnlockedBalance() =>
monero_wallet.getUnlockedBalance(accountIndex: account.id);
2020-11-04 15:54:44 +00:00
Future<void> _afterSyncSave() async {
2020-11-09 23:14:47 +00:00
if (_isSavingAfterSync) {
return;
}
_isSavingAfterSync = true;
try {
final nowTimestamp = DateTime.now().millisecondsSinceEpoch;
final sum = _lastAutosaveTimestamp + _autoAfterSyncSaveInterval;
if (_lastAutosaveTimestamp > 0 && sum < nowTimestamp) {
return;
}
await save();
_lastAutosaveTimestamp = nowTimestamp + _autoAfterSyncSaveInterval;
} catch (e) {
print(e.toString());
}
_isSavingAfterSync = false;
}
2020-06-01 18:13:56 +00:00
2020-11-09 23:14:47 +00:00
Future<void> _afterNewTransactionSave() async {
if (_isSavingAfterNewTransaction) {
2020-06-01 18:13:56 +00:00
return;
}
2020-11-09 23:14:47 +00:00
_isSavingAfterNewTransaction = true;
try {
await save();
} catch (e) {
print(e.toString());
}
_isSavingAfterNewTransaction = false;
2020-11-03 16:57:36 +00:00
}
2020-06-01 18:13:56 +00:00
2020-11-03 16:57:36 +00:00
void _onNewBlock(int height, int blocksLeft, double ptc) async {
2020-11-09 23:14:47 +00:00
print('_onNewBlock called');
2020-11-06 18:54:00 +00:00
if (walletInfo.isRecovery) {
_askForUpdateTransactionHistory();
}
2020-11-03 16:57:36 +00:00
_askForUpdateBalance();
2020-09-15 20:35:49 +00:00
2020-11-06 18:54:00 +00:00
if (blocksLeft < 100) {
2020-10-29 10:49:07 +00:00
syncStatus = SyncedSyncStatus();
2020-11-04 15:54:44 +00:00
await _afterSyncSave();
2020-11-09 23:14:47 +00:00
if (walletInfo.isRecovery) {
setAsRecovered();
}
2020-11-03 16:57:36 +00:00
} else {
syncStatus = SyncingSyncStatus(blocksLeft, ptc);
2020-10-01 16:46:23 +00:00
}
2020-06-01 18:13:56 +00:00
}
2020-11-06 18:54:00 +00:00
void _onNewTransaction() {
2020-11-09 23:14:47 +00:00
print('_onNewTransaction called');
2020-11-06 18:54:00 +00:00
_askForUpdateTransactionHistory();
_askForUpdateBalance();
2020-11-09 23:14:47 +00:00
Timer(Duration(seconds: 1), () => _afterNewTransactionSave());
2020-11-06 18:54:00 +00:00
}
2020-06-01 18:13:56 +00:00
}