import 'dart:async'; import 'package:cw_core/monero_transaction_priority.dart'; import 'package:cw_core/node.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/wallet_base.dart'; import 'package:cw_core/wallet_credentials.dart'; import 'package:cw_core/wallet_info.dart'; import 'package:cw_core/wallet_type.dart'; import 'package:cw_monero/api/exceptions/creation_transaction_exception.dart'; import 'package:cw_wownero/api/wallet.dart'; import 'package:cw_wownero/pending_wownero_transaction.dart'; import 'package:cw_wownero/wownero_wallet.dart'; import 'package:decimal/decimal.dart'; import 'package:flutter_libmonero/core/wallet_creation_service.dart'; import 'package:flutter_libmonero/view_model/send/output.dart' as wownero_output; import 'package:flutter_libmonero/wownero/wownero.dart' as wow_dart; import 'package:isar/isar.dart'; import 'package:stackwallet/db/hive/db.dart'; import 'package:stackwallet/models/isar/models/blockchain_data/address.dart'; import 'package:stackwallet/models/isar/models/blockchain_data/transaction.dart'; import 'package:stackwallet/utilities/amount/amount.dart'; import 'package:stackwallet/utilities/enums/fee_rate_type_enum.dart'; import 'package:stackwallet/utilities/logger.dart'; import 'package:stackwallet/wallets/crypto_currency/coins/wownero.dart'; import 'package:stackwallet/wallets/crypto_currency/crypto_currency.dart'; import 'package:stackwallet/wallets/models/tx_data.dart'; import 'package:stackwallet/wallets/wallet/intermediate/cryptonote_wallet.dart'; import 'package:stackwallet/wallets/wallet/wallet.dart'; import 'package:stackwallet/wallets/wallet/wallet_mixin_interfaces/cw_based_interface.dart'; import 'package:tuple/tuple.dart'; class WowneroWallet extends CryptonoteWallet with CwBasedInterface { WowneroWallet(CryptoCurrencyNetwork network) : super(Wownero(network)); @override Address addressFor({required int index, int account = 0}) { String address = (cwWalletBase as WowneroWalletBase) .getTransactionAddress(account, index); final newReceivingAddress = Address( walletId: walletId, derivationIndex: index, derivationPath: null, value: address, publicKey: [], type: AddressType.cryptonote, subType: AddressSubType.receiving, ); return newReceivingAddress; } @override Future estimateFeeFor(Amount amount, int feeRate) async { if (cwWalletBase == null || cwWalletBase?.syncStatus is! SyncedSyncStatus) { return Amount.zeroWith( fractionDigits: cryptoCurrency.fractionDigits, ); } MoneroTransactionPriority priority; FeeRateType feeRateType = FeeRateType.slow; switch (feeRate) { case 1: priority = MoneroTransactionPriority.regular; feeRateType = FeeRateType.average; break; case 2: priority = MoneroTransactionPriority.medium; feeRateType = FeeRateType.average; break; case 3: priority = MoneroTransactionPriority.fast; feeRateType = FeeRateType.fast; break; case 4: priority = MoneroTransactionPriority.fastest; feeRateType = FeeRateType.fast; break; case 0: default: priority = MoneroTransactionPriority.slow; feeRateType = FeeRateType.slow; break; } dynamic approximateFee; await estimateFeeMutex.protect(() async { { try { final data = await prepareSend( txData: TxData( recipients: [ // This address is only used for getting an approximate fee, never for sending ( address: "WW3iVcnoAY6K9zNdU4qmdvZELefx6xZz4PMpTwUifRkvMQckyadhSPYMVPJhBdYE8P9c27fg9RPmVaWNFx1cDaj61HnetqBiy", amount: amount, isChange: false, ), ], feeRateType: feeRateType, ), ); approximateFee = data.fee!; // unsure why this delay? await Future.delayed(const Duration(milliseconds: 500)); } catch (e) { approximateFee = cwWalletBase!.calculateEstimatedFee( priority, amount.raw.toInt(), ); } } }); if (approximateFee is Amount) { return approximateFee as Amount; } else { return Amount( rawValue: BigInt.from(approximateFee as int), fractionDigits: cryptoCurrency.fractionDigits, ); } } @override Future pingCheck() async { return await (cwWalletBase as WowneroWalletBase?)?.isConnected() ?? false; } @override Future updateNode() async { final node = getCurrentNode(); final host = Uri.parse(node.host).host; await cwWalletBase?.connectToNode( node: Node( uri: "$host:${node.port}", type: WalletType.wownero, trusted: node.trusted ?? false, ), ); } @override Future updateTransactions() async { await (cwWalletBase as WowneroWalletBase?)?.updateTransactions(); final transactions = (cwWalletBase as WowneroWalletBase?)?.transactionHistory?.transactions; // final cachedTransactions = // DB.instance.get(boxName: walletId, key: 'latest_tx_model') // as TransactionData?; // int latestTxnBlockHeight = // DB.instance.get(boxName: walletId, key: "storedTxnDataHeight") // as int? ?? // 0; // // final txidsList = DB.instance // .get(boxName: walletId, key: "cachedTxids") as List? ?? // []; // // final Set cachedTxids = Set.from(txidsList); // TODO: filter to skip cached + confirmed txn processing in next step // final unconfirmedCachedTransactions = // cachedTransactions?.getAllTransactions() ?? {}; // unconfirmedCachedTransactions // .removeWhere((key, value) => value.confirmedStatus); // // if (cachedTransactions != null) { // for (final tx in allTxHashes.toList(growable: false)) { // final txHeight = tx["height"] as int; // if (txHeight > 0 && // txHeight < latestTxnBlockHeight - MINIMUM_CONFIRMATIONS) { // if (unconfirmedCachedTransactions[tx["tx_hash"] as String] == null) { // allTxHashes.remove(tx); // } // } // } // } final List> txnsData = []; if (transactions != null) { for (var tx in transactions.entries) { Address? address; TransactionType type; if (tx.value.direction == TransactionDirection.incoming) { final addressInfo = tx.value.additionalInfo; final addressString = (cwWalletBase as WowneroWalletBase?)?.getTransactionAddress( addressInfo!['accountIndex'] as int, addressInfo['addressIndex'] as int, ); if (addressString != null) { address = await mainDB .getAddresses(walletId) .filter() .valueEqualTo(addressString) .findFirst(); } type = TransactionType.incoming; } else { // txn.address = ""; type = TransactionType.outgoing; } final txn = Transaction( walletId: walletId, txid: tx.value.id, timestamp: (tx.value.date.millisecondsSinceEpoch ~/ 1000), type: type, subType: TransactionSubType.none, amount: tx.value.amount ?? 0, amountString: Amount( rawValue: BigInt.from(tx.value.amount ?? 0), fractionDigits: cryptoCurrency.fractionDigits, ).toJsonString(), fee: tx.value.fee ?? 0, height: tx.value.height, isCancelled: false, isLelantus: false, slateId: null, otherData: null, nonce: null, inputs: [], outputs: [], numberOfMessages: null, ); txnsData.add(Tuple2(txn, address)); } } await mainDB.addNewTransactionData(txnsData, walletId); } @override Future init() async { cwWalletService = wow_dart.wownero .createWowneroWalletService(DB.instance.moneroWalletInfoBox); if (!(await cwWalletService!.isWalletExit(walletId))) { WalletInfo walletInfo; WalletCredentials credentials; try { String name = walletId; final dirPath = await pathForWalletDir(name: name, type: WalletType.wownero); final path = await pathForWallet(name: name, type: WalletType.wownero); credentials = wow_dart.wownero.createWowneroNewWalletCredentials( name: name, language: "English", seedWordsLength: 14, ); walletInfo = WalletInfo.external( id: WalletBase.idFor(name, WalletType.wownero), name: name, type: WalletType.wownero, isRecovery: false, restoreHeight: credentials.height ?? 0, date: DateTime.now(), path: path, dirPath: dirPath, address: '', ); credentials.walletInfo = walletInfo; final _walletCreationService = WalletCreationService( secureStorage: secureStorageInterface, walletService: cwWalletService, keyService: cwKeysStorage, ); // _walletCreationService.changeWalletType(); _walletCreationService.type = WalletType.wownero; // To restore from a seed final wallet = await _walletCreationService.create(credentials); // // final bufferedCreateHeight = (seedWordsLength == 14) // ? getSeedHeightSync(wallet?.seed.trim() as String) // : wownero.getHeightByDate( // date: DateTime.now().subtract(const Duration( // days: // 2))); // subtract a couple days to ensure we have a buffer for SWB final bufferedCreateHeight = getSeedHeightSync(wallet!.seed.trim()); await info.updateRestoreHeight( newRestoreHeight: bufferedCreateHeight, isar: mainDB.isar, ); // special case for xmr/wow. Normally mnemonic + passphrase is saved // before wallet.init() is called await secureStorageInterface.write( key: Wallet.mnemonicKey(walletId: walletId), value: wallet.seed.trim(), ); await secureStorageInterface.write( key: Wallet.mnemonicPassphraseKey(walletId: walletId), value: "", ); walletInfo.restoreHeight = bufferedCreateHeight; walletInfo.address = wallet.walletAddresses.address; await DB.instance .add(boxName: WalletInfo.boxName, value: walletInfo); wallet.close(); } catch (e, s) { Logging.instance.log("$e\n$s", level: LogLevel.Fatal); cwWalletBase?.close(); } await updateNode(); } return super.init(); } @override Future open() async { String? password; try { password = await cwKeysStorage.getWalletPassword(walletName: walletId); } catch (e, s) { throw Exception("Password not found $e, $s"); } cwWalletBase?.close(); cwWalletBase = (await cwWalletService!.openWallet(walletId, password)) as WowneroWalletBase; (cwWalletBase as WowneroWalletBase?)?.onNewBlock = onNewBlock; (cwWalletBase as WowneroWalletBase?)?.onNewTransaction = onNewTransaction; (cwWalletBase as WowneroWalletBase?)?.syncStatusChanged = syncStatusChanged; await updateNode(); await (cwWalletBase as WowneroWalletBase?)?.startSync(); unawaited(refresh()); autoSaveTimer?.cancel(); autoSaveTimer = Timer.periodic( const Duration(seconds: 193), (_) async => await cwWalletBase?.save(), ); } @override Future exitCwWallet() async { (cwWalletBase as WowneroWalletBase?)?.onNewBlock = null; (cwWalletBase as WowneroWalletBase?)?.onNewTransaction = null; (cwWalletBase as WowneroWalletBase?)?.syncStatusChanged = null; await (cwWalletBase as WowneroWalletBase?)?.save(prioritySave: true); } @override Future recover({required bool isRescan}) async { if (isRescan) { await refreshMutex.protect(() async { // clear blockchain info await mainDB.deleteWalletBlockchainData(walletId); var restoreHeight = cwWalletBase?.walletInfo.restoreHeight; highestPercentCached = 0; await cwWalletBase?.rescan(height: restoreHeight); }); unawaited(refresh()); return; } await refreshMutex.protect(() async { final mnemonic = await getMnemonic(); final seedLength = mnemonic.trim().split(" ").length; if (!(seedLength == 14 || seedLength == 25)) { throw Exception("Invalid wownero mnemonic length found: $seedLength"); } try { int height = info.restoreHeight; // extract seed height from 14 word seed if (seedLength == 14) { height = getSeedHeightSync(mnemonic.trim()); } else { // 25 word seed. TODO validate if (height == 0) { height = wow_dart.wownero.getHeightByDate( date: DateTime.now().subtract( const Duration( // subtract a couple days to ensure we have a buffer for SWB days: 2, ), ), ); } } // TODO: info.updateRestoreHeight // await DB.instance // .put(boxName: walletId, key: "restoreHeight", value: height); cwWalletService = wow_dart.wownero .createWowneroWalletService(DB.instance.moneroWalletInfoBox); WalletInfo walletInfo; WalletCredentials credentials; String name = walletId; final dirPath = await pathForWalletDir(name: name, type: WalletType.wownero); final path = await pathForWallet(name: name, type: WalletType.wownero); credentials = wow_dart.wownero.createWowneroRestoreWalletFromSeedCredentials( name: name, height: height, mnemonic: mnemonic.trim(), ); try { walletInfo = WalletInfo.external( id: WalletBase.idFor(name, WalletType.wownero), name: name, type: WalletType.wownero, isRecovery: false, restoreHeight: credentials.height ?? 0, date: DateTime.now(), path: path, dirPath: dirPath, // TODO: find out what to put for address address: ''); credentials.walletInfo = walletInfo; final cwWalletCreationService = WalletCreationService( secureStorage: secureStorageInterface, walletService: cwWalletService, keyService: cwKeysStorage, ); cwWalletCreationService.type = WalletType.wownero; // To restore from a seed final wallet = await cwWalletCreationService .restoreFromSeed(credentials) as WowneroWalletBase; walletInfo.address = wallet.walletAddresses.address; await DB.instance .add(boxName: WalletInfo.boxName, value: walletInfo); cwWalletBase?.close(); cwWalletBase = wallet; } catch (e, s) { Logging.instance.log("$e\n$s", level: LogLevel.Fatal); } await updateNode(); await cwWalletBase?.rescan(height: credentials.height); cwWalletBase?.close(); } catch (e, s) { Logging.instance.log( "Exception rethrown from recoverFromMnemonic(): $e\n$s", level: LogLevel.Error); rethrow; } }); } @override Future prepareSend({required TxData txData}) async { try { final feeRate = txData.feeRateType; if (feeRate is FeeRateType) { MoneroTransactionPriority feePriority; switch (feeRate) { case FeeRateType.fast: feePriority = MoneroTransactionPriority.fast; break; case FeeRateType.average: feePriority = MoneroTransactionPriority.regular; break; case FeeRateType.slow: feePriority = MoneroTransactionPriority.slow; break; default: throw ArgumentError("Invalid use of custom fee"); } Future? awaitPendingTransaction; try { // check for send all bool isSendAll = false; final balance = await availableBalance; if (txData.amount! == balance && txData.recipients!.first.amount == balance) { isSendAll = true; } List outputs = []; for (final recipient in txData.recipients!) { final output = wownero_output.Output(cwWalletBase!); output.address = recipient.address; output.sendAll = isSendAll; String amountToSend = recipient.amount.decimal.toString(); output.setCryptoAmount(amountToSend); } final tmp = wow_dart.wownero.createWowneroTransactionCreationCredentials( outputs: outputs, priority: feePriority, ); await prepareSendMutex.protect(() async { awaitPendingTransaction = cwWalletBase!.createTransaction(tmp); }); } catch (e, s) { Logging.instance.log("Exception rethrown from prepareSend(): $e\n$s", level: LogLevel.Warning); } PendingWowneroTransaction pendingWowneroTransaction = await (awaitPendingTransaction!) as PendingWowneroTransaction; final realFee = Amount.fromDecimal( Decimal.parse(pendingWowneroTransaction.feeFormatted), fractionDigits: cryptoCurrency.fractionDigits, ); return txData.copyWith( fee: realFee, pendingWowneroTransaction: pendingWowneroTransaction, ); } else { throw ArgumentError("Invalid fee rate argument provided!"); } } catch (e, s) { Logging.instance.log("Exception rethrown from prepare send(): $e\n$s", level: LogLevel.Info); if (e.toString().contains("Incorrect unlocked balance")) { throw Exception("Insufficient balance!"); } else if (e is CreationTransactionException) { throw Exception("Insufficient funds to pay for transaction fee!"); } else { throw Exception("Transaction failed with error code $e"); } } } @override Future confirmSend({required TxData txData}) async { try { try { await txData.pendingWowneroTransaction!.commit(); Logging.instance.log( "transaction ${txData.pendingWowneroTransaction!.id} has been sent", level: LogLevel.Info); return txData.copyWith(txid: txData.pendingWowneroTransaction!.id); } catch (e, s) { Logging.instance.log("${info.name} wownero confirmSend: $e\n$s", level: LogLevel.Error); rethrow; } } catch (e, s) { Logging.instance.log("Exception rethrown from confirmSend(): $e\n$s", level: LogLevel.Info); rethrow; } } @override Future get availableBalance async { try { int runningBalance = 0; for (final entry in (cwWalletBase as WowneroWalletBase?)!.balance!.entries) { runningBalance += entry.value.unlockedBalance; } return Amount( rawValue: BigInt.from(runningBalance), fractionDigits: cryptoCurrency.fractionDigits, ); } catch (_) { return info.cachedBalance.spendable; } } @override Future get totalBalance async { try { final balanceEntries = (cwWalletBase as WowneroWalletBase?)?.balance?.entries; if (balanceEntries != null) { int bal = 0; for (var element in balanceEntries) { bal = bal + element.value.fullBalance; } return Amount( rawValue: BigInt.from(bal), fractionDigits: cryptoCurrency.fractionDigits, ); } else { final transactions = cwWalletBase!.transactionHistory!.transactions; int transactionBalance = 0; for (var tx in transactions!.entries) { if (tx.value.direction == TransactionDirection.incoming) { transactionBalance += tx.value.amount!; } else { transactionBalance += -tx.value.amount! - tx.value.fee!; } } return Amount( rawValue: BigInt.from(transactionBalance), fractionDigits: cryptoCurrency.fractionDigits, ); } } catch (_) { return info.cachedBalance.total; } } }