cake_wallet/cw_haven/lib/haven_wallet.dart

import 'dart:async';
import 'package:cw_core/crypto_currency.dart';
import 'package:cw_core/transaction_priority.dart';
import 'package:cw_haven/haven_transaction_creation_credentials.dart';
import 'package:cw_core/monero_amount_format.dart';
import 'package:cw_haven/haven_transaction_creation_exception.dart';
import 'package:cw_haven/haven_transaction_info.dart';
import 'package:cw_haven/haven_wallet_addresses.dart';
import 'package:cw_core/monero_wallet_utils.dart';
import 'package:cw_haven/api/structs/pending_transaction.dart';
import 'package:flutter/foundation.dart';
import 'package:mobx/mobx.dart';
import 'package:cw_haven/api/transaction_history.dart'
    as haven_transaction_history;
//import 'package:cw_haven/wallet.dart';
import 'package:cw_haven/api/wallet.dart' as haven_wallet;
import 'package:cw_haven/api/transaction_history.dart' as transaction_history;
import 'package:cw_haven/api/monero_output.dart';
import 'package:cw_haven/pending_haven_transaction.dart';
import 'package:cw_core/monero_wallet_keys.dart';
import 'package:cw_core/monero_balance.dart';
import 'package:cw_haven/haven_transaction_history.dart';
import 'package:cw_core/account.dart';
import 'package:cw_core/pending_transaction.dart';
import 'package:cw_core/wallet_base.dart';
import 'package:cw_core/sync_status.dart';
import 'package:cw_core/wallet_info.dart';
import 'package:cw_core/node.dart';
import 'package:cw_core/monero_transaction_priority.dart';
import 'package:cw_haven/haven_balance.dart';

part 'haven_wallet.g.dart';

const moneroBlockSize = 1000;

class HavenWallet = HavenWalletBase with _$HavenWallet;

abstract class HavenWalletBase extends WalletBase<MoneroBalance,
    HavenTransactionHistory, HavenTransactionInfo> with Store {
  HavenWalletBase({WalletInfo walletInfo})
      : super(walletInfo) {
    transactionHistory = HavenTransactionHistory();
    balance = ObservableMap.of(getHavenBalance(accountIndex: 0));
    _isTransactionUpdating = false;
    _hasSyncAfterStartup = false;
    walletAddresses = HavenWalletAddresses(walletInfo);
    _onAccountChangeReaction = reaction((_) => walletAddresses.account,
            (Account account) {
      balance.addAll(getHavenBalance(accountIndex: account.id));
      walletAddresses.updateSubaddressList(accountIndex: account.id);
    });
  }

  static const int _autoSaveInterval = 30;

  @override
  HavenWalletAddresses walletAddresses;

  @override
  @observable
  SyncStatus syncStatus;

  @override
  @observable
  ObservableMap<CryptoCurrency, MoneroBalance> balance;

  @override
  String get seed => haven_wallet.getSeed();

  @override
  MoneroWalletKeys get keys => MoneroWalletKeys(
      privateSpendKey: haven_wallet.getSecretSpendKey(),
      privateViewKey: haven_wallet.getSecretViewKey(),
      publicSpendKey: haven_wallet.getPublicSpendKey(),
      publicViewKey: haven_wallet.getPublicViewKey());

  haven_wallet.SyncListener _listener;
  ReactionDisposer _onAccountChangeReaction;
  bool _isTransactionUpdating;
  bool _hasSyncAfterStartup;
  Timer _autoSaveTimer;

  Future<void> init() async {
    await walletAddresses.init();
    balance.addAll(getHavenBalance(accountIndex: walletAddresses.account.id ?? 0));
    _setListeners();
    await updateTransactions();

    if (walletInfo.isRecovery) {
      haven_wallet.setRecoveringFromSeed(isRecovery: walletInfo.isRecovery);

      if (haven_wallet.getCurrentHeight() <= 1) {
        haven_wallet.setRefreshFromBlockHeight(
            height: walletInfo.restoreHeight);
      }
    }

    _autoSaveTimer = Timer.periodic(
       Duration(seconds: _autoSaveInterval),
       (_) async => await save());
  }

  @override
  void close() {
    _listener?.stop();
    _onAccountChangeReaction?.reaction?.dispose();
    _autoSaveTimer?.cancel();
  }

  @override
  Future<void> connectToNode({@required Node node}) async {
    try {
      syncStatus = ConnectingSyncStatus();
      await haven_wallet.setupNode(
          address: node.uriRaw,
          login: node.login,
          password: node.password,
          useSSL: node.useSSL,
          isLightWallet: false); // FIXME: hardcoded value
      syncStatus = ConnectedSyncStatus();
    } catch (e) {
      syncStatus = FailedSyncStatus();
      print(e);
    }
  }

  @override
  Future<void> startSync() async {
    try {
      _setInitialHeight();
    } catch (_) {}

    try {
      syncStatus = StartingSyncStatus();
      haven_wallet.startRefresh();
      _setListeners();
      _listener?.start();
    } catch (e) {
      syncStatus = FailedSyncStatus();
      print(e);
      rethrow;
    }
  }

  @override
  Future<PendingTransaction> createTransaction(Object credentials) async {
    final _credentials = credentials as HavenTransactionCreationCredentials;
    final outputs = _credentials.outputs;
    final hasMultiDestination = outputs.length > 1;
    final unlockedBalance =
    haven_wallet.getUnlockedBalance(accountIndex: walletAddresses.account.id);

    PendingTransactionDescription pendingTransactionDescription;

    if (!(syncStatus is SyncedSyncStatus)) {
      throw HavenTransactionCreationException('The wallet is not synced.');
    }

    if (hasMultiDestination) {
      if (outputs.any((item) => item.sendAll
          || item.formattedCryptoAmount <= 0)) {
        throw HavenTransactionCreationException('Wrong balance. Not enough XMR on your balance.');
      }

      final int totalAmount = outputs.fold(0, (acc, value) =>
          acc + value.formattedCryptoAmount);

      if (unlockedBalance < totalAmount) {
        throw HavenTransactionCreationException('Wrong balance. Not enough XMR on your balance.');
      }

      final moneroOutputs = outputs.map((output) =>
          MoneroOutput(
              address: output.address,
              amount: output.cryptoAmount.replaceAll(',', '.')))
          .toList();

      pendingTransactionDescription =
      await transaction_history.createTransactionMultDest(
          outputs: moneroOutputs,
          priorityRaw: _credentials.priority.serialize(),
          accountIndex: walletAddresses.account.id);
    } else {
      final output = outputs.first;
      final address = output.address;
      final amount = output.sendAll
          ? null
          : output.cryptoAmount.replaceAll(',', '.');
      final formattedAmount = output.sendAll
          ? null
          : output.formattedCryptoAmount;

      if ((formattedAmount != null && unlockedBalance < formattedAmount) ||
          (formattedAmount == null && unlockedBalance <= 0)) {
        final formattedBalance = moneroAmountToString(amount: unlockedBalance);

        throw HavenTransactionCreationException(
            'Incorrect unlocked balance. Unlocked: $formattedBalance. Transaction amount: ${output.cryptoAmount}.');
      }

      pendingTransactionDescription =
      await transaction_history.createTransaction(
          address: address,
          assetType: _credentials.assetType,
          amount: amount,
          priorityRaw: _credentials.priority.serialize(),
          accountIndex: walletAddresses.account.id);
    }

    return PendingHavenTransaction(pendingTransactionDescription, CryptoCurrency.fromString(_credentials.assetType));
  }

  @override
  int calculateEstimatedFee(TransactionPriority priority, int amount) {
    // FIXME: hardcoded value;

    if (priority is MoneroTransactionPriority) {
      switch (priority) {
        case MoneroTransactionPriority.slow:
          return 24590000;
        case MoneroTransactionPriority.regular:
          return 123050000;
        case MoneroTransactionPriority.medium:
          return 245029999;
        case MoneroTransactionPriority.fast:
          return 614530000;
        case MoneroTransactionPriority.fastest:
          return 26021600000;
      }
    }

    return 0;
  }

  @override
  Future<void> save() async {
    await walletAddresses.updateAddressesInBox();
    await backupWalletFiles(name);
    await haven_wallet.store();
  }

  Future<int> getNodeHeight() async => haven_wallet.getNodeHeight();

  Future<bool> isConnected() async => haven_wallet.isConnected();

  Future<void> setAsRecovered() async {
    walletInfo.isRecovery = false;
    await walletInfo.save();
  }

  @override
  Future<void> rescan({int height}) async {
    walletInfo.restoreHeight = height;
    walletInfo.isRecovery = true;
    haven_wallet.setRefreshFromBlockHeight(height: height);
    haven_wallet.rescanBlockchainAsync();
    await startSync();
    _askForUpdateBalance();
    walletAddresses.accountList.update();
    await _askForUpdateTransactionHistory();
    await save();
    await walletInfo.save();
  }

  String getTransactionAddress(int accountIndex, int addressIndex) =>
      haven_wallet.getAddress(
          accountIndex: accountIndex,
          addressIndex: addressIndex);

  @override
  Future<Map<String, HavenTransactionInfo>> fetchTransactions() async {
    haven_transaction_history.refreshTransactions();
    return _getAllTransactions(null).fold<Map<String, HavenTransactionInfo>>(
        <String, HavenTransactionInfo>{},
        (Map<String, HavenTransactionInfo> acc, HavenTransactionInfo tx) {
      acc[tx.id] = tx;
      return acc;
    });
  }

  Future<void> updateTransactions() async {
    try {
      if (_isTransactionUpdating) {
        return;
      }

      _isTransactionUpdating = true;
      final transactions = await fetchTransactions();
      transactionHistory.addMany(transactions);
      await transactionHistory.save();
      _isTransactionUpdating = false;
    } catch (e) {
      print(e);
      _isTransactionUpdating = false;
    }
  }

  List<HavenTransactionInfo> _getAllTransactions(dynamic _) => haven_transaction_history
          .getAllTransations()
          .map((row) => HavenTransactionInfo.fromRow(row))
          .toList();

  void _setListeners() {
    _listener?.stop();
    _listener = haven_wallet.setListeners(_onNewBlock, _onNewTransaction);
  }

  void _setInitialHeight() {
    if (walletInfo.isRecovery) {
      return;
    }

    final currentHeight = haven_wallet.getCurrentHeight();

    if (currentHeight <= 1) {
      final height = _getHeightByDate(walletInfo.date);
      haven_wallet.setRecoveringFromSeed(isRecovery: true);
      haven_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 = haven_wallet.getNodeHeightSync();
    final heightDistance = _getHeightDistance(date);

    if (nodeHeight <= 0) {
      return 0;
    }

    return nodeHeight - heightDistance;
  }

  void _askForUpdateBalance() =>
      balance.addAll(getHavenBalance(accountIndex: walletAddresses.account.id));

  Future<void> _askForUpdateTransactionHistory() async =>
      await updateTransactions();

  void _onNewBlock(int height, int blocksLeft, double ptc) async {
    try {
      if (walletInfo.isRecovery) {
        await _askForUpdateTransactionHistory();
        _askForUpdateBalance();
        walletAddresses.accountList.update();
      }

      if (blocksLeft < 100) {
        await _askForUpdateTransactionHistory();
        _askForUpdateBalance();
        walletAddresses.accountList.update();
        syncStatus = SyncedSyncStatus();

        if (!_hasSyncAfterStartup) {
           _hasSyncAfterStartup = true;
           await save();
         }

        if (walletInfo.isRecovery) {
          await setAsRecovered();
        }
      } else {
        syncStatus = SyncingSyncStatus(blocksLeft, ptc);
      }
    } catch (e) {
      print(e.toString());
    }
  }

  void _onNewTransaction() async {
    try {
      await _askForUpdateTransactionHistory();
      _askForUpdateBalance();
      await Future<void>.delayed(Duration(seconds: 1));
    } catch (e) {
      print(e.toString());
    }
  }
}