cake_wallet/cw_nano/lib/nano_wallet.dart

import 'dart:convert';

import 'package:cw_core/crypto_currency.dart';
import 'package:cw_core/node.dart';
import 'package:cw_core/pathForWallet.dart';
import 'package:cw_core/pending_transaction.dart';
import 'package:cw_core/sync_status.dart';
import 'package:cw_core/transaction_direction.dart';
import 'package:cw_core/transaction_priority.dart';
import 'package:cw_core/wallet_addresses.dart';
import 'package:cw_core/wallet_info.dart';
import 'package:cw_nano/file.dart';
import 'package:cw_nano/nano_balance.dart';
import 'package:cw_nano/nano_client.dart';
import 'package:cw_nano/nano_transaction_history.dart';
import 'package:cw_nano/nano_transaction_info.dart';
import 'package:cw_nano/nano_util.dart';
import 'package:cw_nano/nano_wallet_info.dart';
import 'package:mobx/mobx.dart';
import 'dart:async';
import 'package:cw_nano/nano_wallet_addresses.dart';
import 'package:cw_core/wallet_base.dart';
import 'package:web3dart/web3dart.dart';
import 'package:bip39/bip39.dart' as bip39;
import 'package:bip32/bip32.dart' as bip32;

part 'nano_wallet.g.dart';

class NanoWallet = NanoWalletBase with _$NanoWallet;

abstract class NanoWalletBase
    extends WalletBase<NanoBalance, NanoTransactionHistory, NanoTransactionInfo> with Store {
  NanoWalletBase({
    required NanoWalletInfo walletInfo,
    required String mnemonic,
    required String password,
    NanoBalance? initialBalance,
  })  : syncStatus = NotConnectedSyncStatus(),
        _password = password,
        _mnemonic = mnemonic,
        _derivationType = walletInfo.derivationType,
        _isTransactionUpdating = false,
        _client = NanoClient(),
        walletAddresses = NanoWalletAddresses(walletInfo),
        balance = ObservableMap<CryptoCurrency, NanoBalance>.of({
          CryptoCurrency.nano: initialBalance ??
              NanoBalance(currentBalance: BigInt.zero, receivableBalance: BigInt.zero)
        }),
        super(walletInfo) {
    this.walletInfo = walletInfo;
    transactionHistory = NanoTransactionHistory(walletInfo: walletInfo, password: password);
  }

  final String _mnemonic;
  final String _password;
  final DerivationType _derivationType;

  late final String _privateKey;
  late final String _publicAddress;
  late final String _seedKey;

  late NanoClient _client;
  bool _isTransactionUpdating;

  @override
  WalletAddresses walletAddresses;

  @override
  @observable
  SyncStatus syncStatus;

  @override
  @observable
  late ObservableMap<CryptoCurrency, NanoBalance> balance;

  // initialize the different forms of private / public key we'll need:
  Future<void> init() async {
    final String type = (_derivationType == DerivationType.nano) ? "standard" : "hd";

    _seedKey = bip39.mnemonicToEntropy(_mnemonic).toUpperCase();
    _privateKey = await NanoUtil.uniSeedToPrivate(_seedKey, 0, type);
    _publicAddress = await NanoUtil.uniSeedToAddress(_seedKey, 0, type);
    this.walletInfo.address = _publicAddress;

    await walletAddresses.init();
    await transactionHistory.init();
    await save();
  }

  @override
  int calculateEstimatedFee(TransactionPriority priority, int? amount) {
    return 0; // always 0 :)
  }

  @override
  Future<void> changePassword(String password) {
    print("e");
    throw UnimplementedError("changePassword");
  }

  @override
  void close() {
    _client.stop();
  }

  @action
  @override
  Future<void> connectToNode({required Node node}) async {
    try {
      syncStatus = ConnectingSyncStatus();
      final isConnected = _client.connect(node);
      if (!isConnected) {
        throw Exception("Ethereum Node connection failed");
      }
      // _client.setListeners(_privateKey.address, _onNewTransaction);
      _updateBalance();
      syncStatus = ConnectedSyncStatus();
    } catch (e) {
      syncStatus = FailedSyncStatus();
    }
  }

  @override
  Future<PendingTransaction> createTransaction(Object credentials) async {
    print("g");
    print(credentials);
    // throw UnimplementedError();

    // final _credentials = credentials as EthereumTransactionCredentials;
    // final outputs = _credentials.outputs;
    // final hasMultiDestination = outputs.length > 1;
    // final _erc20Balance = balance[_credentials.currency]!;
    // BigInt totalAmount = BigInt.zero;
    // int exponent =
    //     _credentials.currency is Erc20Token ? (_credentials.currency as Erc20Token).decimal : 18;
    // BigInt amountToEthereumMultiplier = BigInt.from(pow(10, exponent));

    // if (hasMultiDestination) {
    //   if (outputs.any((item) => item.sendAll || (item.formattedCryptoAmount ?? 0) <= 0)) {
    //     throw EthereumTransactionCreationException(_credentials.currency);
    //   }

    //   final totalOriginalAmount = EthereumFormatter.parseEthereumAmountToDouble(
    //       outputs.fold(0, (acc, value) => acc + (value.formattedCryptoAmount ?? 0)));
    //   totalAmount = BigInt.from(totalOriginalAmount) * amountToEthereumMultiplier;

    //   if (_erc20Balance.balance < totalAmount) {
    //     throw EthereumTransactionCreationException(_credentials.currency);
    //   }
    // } else {
    //   final output = outputs.first;
    //   final BigInt allAmount = _erc20Balance.balance - BigInt.from(feeRate(_credentials.priority!));
    //   final totalOriginalAmount =
    //       EthereumFormatter.parseEthereumAmountToDouble(output.formattedCryptoAmount ?? 0);
    //   totalAmount = output.sendAll
    //       ? allAmount
    //       : BigInt.from(totalOriginalAmount) * amountToEthereumMultiplier;

    //   if (_erc20Balance.balance < totalAmount) {
    //     throw EthereumTransactionCreationException(_credentials.currency);
    //   }
    // }

    // final pendingEthereumTransaction = await _client.signTransaction(
    //   privateKey: _privateKey,
    //   toAddress: _credentials.outputs.first.address,
    //   amount: totalAmount.toString(),
    //   gas: _priorityFees[_credentials.priority!.raw],
    //   priority: _credentials.priority!,
    //   currency: _credentials.currency,
    //   exponent: exponent,
    //   contractAddress: _credentials.currency is Erc20Token
    //       ? (_credentials.currency as Erc20Token).contractAddress
    //       : null,
    // );

    // return pendingEthereumTransaction;
  }

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

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

  @override
  Future<Map<String, NanoTransactionInfo>> fetchTransactions() async {
    String address = _publicAddress;

    final transactions = await _client.fetchTransactions(address);

    final Map<String, NanoTransactionInfo> result = {};

    for (var transactionModel in transactions) {
      result[transactionModel.hash] = NanoTransactionInfo(
        id: transactionModel.hash,
        amountRaw: transactionModel.amount,
        height: transactionModel.height,
        direction: transactionModel.account == address
            ? TransactionDirection.outgoing
            : TransactionDirection.incoming,
        confirmed: transactionModel.confirmed,
        date: transactionModel.date ?? DateTime.now(),
        confirmations: transactionModel.confirmed ? 1 : 0,
      );
    }

    return result;
  }

  @override
  Object get keys {
    print("j");
    throw UnimplementedError("keys");
  }

  @override
  Future<void> rescan({required int height}) async {
    fetchTransactions();
    _updateBalance();
    return;
  }

  @override
  Future<void> save() async {
    await walletAddresses.updateAddressesInBox();
    final path = await makePath();
    await write(path: path, password: _password, data: toJSON());
    await transactionHistory.save();
  }

  @override
  String get seed => _mnemonic;

  @action
  @override
  Future<void> startSync() async {
    try {
      syncStatus = AttemptingSyncStatus();
      await _updateBalance();
      await updateTransactions();

      syncStatus = SyncedSyncStatus();
    } catch (e) {
      syncStatus = FailedSyncStatus();
    }
  }

  Future<String> makePath() async => pathForWallet(name: walletInfo.name, type: walletInfo.type);

  String toJSON() => json.encode({
        'seedKey': _seedKey,
        'mnemonic': _mnemonic,
        // 'balance': balance[currency]!.toJSON(),
        'derivationType': _derivationType.toString()
      });

  static Future<NanoWallet> open({
    required String name,
    required String password,
    required WalletInfo walletInfo,
  }) async {
    final path = await pathForWallet(name: name, type: walletInfo.type);
    final jsonSource = await read(path: path, password: password);
    final data = json.decode(jsonSource) as Map;
    final mnemonic = data['mnemonic'] as String;
    final balance = NanoBalance.fromString(
        formattedCurrentBalance: data['balance'] as String? ?? "0",
        formattedReceivableBalance: "0");

    DerivationType derivationType = DerivationType.bip39;
    if (data['derivationType'] == "DerivationType.nano") {
      derivationType = DerivationType.nano;
    }

    final nanoWalletInfo = NanoWalletInfo(
      walletInfo: walletInfo,
      derivationType: derivationType,
    );

    return NanoWallet(
      walletInfo: nanoWalletInfo,
      password: password,
      mnemonic: mnemonic,
      initialBalance: balance,
    );
  }

  Future<void> _updateBalance() async {
    balance[currency] = await _client.getBalance(_publicAddress);
    await save();
  }

  Future<void>? updateBalance() async => await _updateBalance();

  void _onNewTransaction(FilterEvent event) {
    throw UnimplementedError();
  }

  @override
  Future<void> renameWalletFiles(String newWalletName) async {
    print("rename");
    throw UnimplementedError();
  }
}