mirror of
https://github.com/cake-tech/cake_wallet.git
synced 2024-12-22 19:49:22 +00:00
1ce60d62b3
* Revert "Revert btc address types"
This reverts commit a49e57e3
* Re-add Bitcoin Address types
Fix conflicts with main
* fix: label issues, clear spent utxo
* chore: deps
* fix: build
* fix: missing types
* feat: new electrs API & changes, fixes for last block scanning
* Update Monero
* not sure why it's failing
* Enable Exolix
Improve service updates indicator
New versions
* Add exolix Api token to limits api
* Ignore reporting network issues
* Change default bitcoin node
* Merge main and update linux version
* Update app version [skip ci]
* New versions
* Fix conflicts and update linux version
* minor fix
* feat: Scan Silent Payments homepage toggle
* chore: build configure
* feat: generic fixes, testnet UI improvements, useSSL on bitcoin nodes
* fix: invalid Object in sendData
* feat: improve addresses page & address book displays
* feat: silent payments labeled addresses disclaimer
* fix: missing i18n
* chore: print
* feat: single block scan, rescan by date working for btc mainnet
* feat: new cake features page replace market page, move sp scan toggle, auto switch node pop up alert
* feat: delete silent addresses
* fix: red dot in non ssl nodes
* fix: inconsistent connection states, fix tx history
* fix: tx & balance displays, cpfp sending
* feat: new rust lib
* chore: node path
* fix: check node based on network
* fix: missing txcount from addresses
* style: padding in feature page cards
* fix: restore not getting all wallet addresses by type
* fix: auto switch node broken
* fix: silent payment txs not being restored
* update linux version
* feat: change scanning to subscription model, sync improvements
* fix: scan re-subscription
* fix: default nodes
* fix: improve scanning by date, fix single block scan
* refactor: common function for input tx selection
* various fixes for build issues
* initial monero.dart implementation
* ...
* multiple wallets
new lib
minor fixes
* other fixes from monero.dart and monero_c
* fix: nodes & build
* update build scripts
fix polyseed
* remove unnecessary code
* Add windows app, build scripts and build guide for it.
* Minor fix in generated monero configs
* Merge and fix main
* fix: send all with multiple outs
* add missing monero_c command
* add android build script
* update version
* Merge and fix main
* undo android ndk removal
* Fix modified exception_handler.dart
* Temporarily remove haven
* fix build issues
* fix pr script
* Fixes for build monero.dart (monero_c) for windows.
* monero build script
* wip: ios build script
* refactor: unchanged file
* Added build guides for iOS and macOS. Replaced nproc call on macOS. Added macOS configuration for configure_cake_wallet.sh script.
* Update monero.dart and monero_c versions.
* Add missed windows build scripts
* Update the application configuration for windows build script.
* Update cw_monero pubspec lock file for monero.dart
* Update pr_test_build.yml
* chore: upgrade
* chore: merge changes
* refactor: unchanged files [skip ci]
* Fix conflicts with main
* fix for multiple wallets
* update app version [skip ci]
* Add tron to windows application configuration.
* Add macOS option for description message in configure_cake_wallet.sh
* fix missing encryption utils in hardware wallet functions [skip ci]
* fix conflicts
* Include missed monero dll for windows.
* reformatting [skip ci]
* fix conflicts with main
* Disable haven configuration for iOS as default. Add ability to configure cakewallet for iOS with for configuration script. Remove cw_shared configuration for cw_monero.
* fix: scan fixes, add date, allow sending while scanning
* add missing nano secrets file [skip ci]
* ios library
* don't pull prebuilds android
* Add auto generation of manifest file for android project even for iOS, macOS, Windows.
* remove tron
* feat: sync fixes, sp settings
* feat: fix resyncing
* store crash fix
* make init async so it won't lag
disable print starts
* fix monero_c build issues
* libstdc++
* merge main and update version
* Fix MacOS saving wallet file issue
Fix Secure Storage issue (somehow)
* update pubspec.lock
* fix build script
* Use dylib as iOS framework. Use custom path for loading of iOS framework for monero.dart. Add script for generate iOS framework for monero wallet.
* fix: date from height logic, status disconnected & chain tip get
* fix: params
* feat: electrum migration if using cake electrum
* fix nodes
update versions
* re-enable tron
* update sp_scanner to work on iOS [skip ci]
* bump monero_c hash
* bump monero_c commit
* bump moneroc version
* bump monero_c commit
* Add ability to build monero wallet lib as universal lib. Update macOS build guide. Change default arch for macOS project to .
* fix: wrong socket for old electrum nodes
* update version
* Fix unchecked wallet type call
* get App Dir correctly in default_settings_migration.dart
* handle previous issue with fetching linux documents directory [skip ci]
* backup fix
* fix NTFS issues
* Add Tron
Update Linux version
* Close the wallet when the wallet gets changed
* fix: double balance
* feat: node domain
* fix: menu name
* bump monero_c commit
* fix: update tip on set scanning
* fix: connection switching back and forth
* feat: check if node is electrs, and supports sp
* chore: fix build
* minor enhancements
* fixes and enhancements
* solve conflicts with main
* Only stop wallet on rename and delete
* fix: status toggle
* minor enhancement
* Monero.com fixes
* bump monero_c commit
* update sp_scanner to include windows and linux
* merge main
* Update macOS build guide. Change brew dependencies for build unbound locally.
* fix: Tron file write, build scripts
* - merge linux with Monero Dart
- Temporarily disable Monero
* fix other issues with linux
* linux ci
fix build script
* Update pr_test_build_linux.yml
install required packages
* add linux desktop dependencies
* don't use apk in linux build releases
* don't copy the file to test-apk
* fix linux runtime issues
* remove libc++_shared.so
* fix issues with linux
* prepare both android and linux (because otherwise it will fail)
* ci script updates
* run apt update
* bump image to ubuntu 22.04
note: remember to put it down later
* bump python version
* remove some dependencies
* remove unused import
* add missing dependencies
* fix dependencies
* some fixes
* remove print [skip ci]
* Add back RunnerBase.entitlements
minor fixes [skip ci]
* fix memory leak / infinite recurrsion when opening xmr wallet
* url_launcher_linux: 3.1.1 # https://github.com/flutter/flutter/issues/153083
* fix conflicts with main
* handle walletKeysFile with encryptionUtils
* update app version [skip ci]
* add wownero [skip ci]
---------
Co-authored-by: OmarHatem <omarh.ismail1@gmail.com>
Co-authored-by: Rafael Saes <git@rafael.saes.dev>
Co-authored-by: M <m@cakewallet.com>
Co-authored-by: Konstantin Ullrich <konstantinullrich12@gmail.com>
354 lines
12 KiB
Dart
354 lines
12 KiB
Dart
import 'dart:ffi';
|
|
import 'dart:io';
|
|
import 'package:cw_core/monero_wallet_utils.dart';
|
|
import 'package:cw_core/pathForWallet.dart';
|
|
import 'package:cw_core/unspent_coins_info.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_service.dart';
|
|
import 'package:cw_core/wallet_type.dart';
|
|
import 'package:cw_core/get_height_by_date.dart';
|
|
import 'package:cw_wownero/api/exceptions/wallet_opening_exception.dart';
|
|
import 'package:cw_wownero/api/wallet_manager.dart' as wownero_wallet_manager;
|
|
import 'package:cw_wownero/api/wallet_manager.dart';
|
|
import 'package:cw_wownero/wownero_wallet.dart';
|
|
import 'package:flutter/widgets.dart';
|
|
import 'package:hive/hive.dart';
|
|
import 'package:polyseed/polyseed.dart';
|
|
import 'package:monero/wownero.dart' as wownero;
|
|
|
|
class WowneroNewWalletCredentials extends WalletCredentials {
|
|
WowneroNewWalletCredentials(
|
|
{required String name, required this.language, required this.isPolyseed, String? password})
|
|
: super(name: name, password: password);
|
|
|
|
final String language;
|
|
final bool isPolyseed;
|
|
}
|
|
|
|
class WowneroRestoreWalletFromSeedCredentials extends WalletCredentials {
|
|
WowneroRestoreWalletFromSeedCredentials(
|
|
{required String name, required this.mnemonic, int height = 0, String? password})
|
|
: super(name: name, password: password, height: height);
|
|
|
|
final String mnemonic;
|
|
}
|
|
|
|
class WowneroWalletLoadingException implements Exception {
|
|
@override
|
|
String toString() => 'Failure to load the wallet.';
|
|
}
|
|
|
|
class WowneroRestoreWalletFromKeysCredentials extends WalletCredentials {
|
|
WowneroRestoreWalletFromKeysCredentials(
|
|
{required String name,
|
|
required String password,
|
|
required this.language,
|
|
required this.address,
|
|
required this.viewKey,
|
|
required this.spendKey,
|
|
int height = 0})
|
|
: super(name: name, password: password, height: height);
|
|
|
|
final String language;
|
|
final String address;
|
|
final String viewKey;
|
|
final String spendKey;
|
|
}
|
|
|
|
class WowneroWalletService extends WalletService<
|
|
WowneroNewWalletCredentials,
|
|
WowneroRestoreWalletFromSeedCredentials,
|
|
WowneroRestoreWalletFromKeysCredentials,
|
|
WowneroNewWalletCredentials> {
|
|
WowneroWalletService(this.walletInfoSource, this.unspentCoinsInfoSource);
|
|
|
|
final Box<WalletInfo> walletInfoSource;
|
|
final Box<UnspentCoinsInfo> unspentCoinsInfoSource;
|
|
|
|
static bool walletFilesExist(String path) =>
|
|
!File(path).existsSync() && !File('$path.keys').existsSync();
|
|
|
|
@override
|
|
WalletType getType() => WalletType.wownero;
|
|
|
|
@override
|
|
Future<WowneroWallet> create(WowneroNewWalletCredentials credentials, {bool? isTestnet}) async {
|
|
try {
|
|
final path = await pathForWallet(name: credentials.name, type: getType());
|
|
|
|
if (credentials.isPolyseed) {
|
|
final polyseed = Polyseed.create();
|
|
final lang = PolyseedLang.getByEnglishName(credentials.language);
|
|
|
|
final heightOverride =
|
|
getWowneroHeightByDate(date: DateTime.now().subtract(Duration(days: 2)));
|
|
|
|
return _restoreFromPolyseed(
|
|
path, credentials.password!, polyseed, credentials.walletInfo!, lang,
|
|
overrideHeight: heightOverride);
|
|
}
|
|
|
|
await wownero_wallet_manager.createWallet(
|
|
path: path, password: credentials.password!, language: credentials.language);
|
|
final wallet = WowneroWallet(
|
|
walletInfo: credentials.walletInfo!, unspentCoinsInfo: unspentCoinsInfoSource, password: credentials.password!);
|
|
await wallet.init();
|
|
|
|
return wallet;
|
|
} catch (e) {
|
|
// TODO: Implement Exception for wallet list service.
|
|
print('WowneroWalletsManager Error: ${e.toString()}');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<bool> isWalletExit(String name) async {
|
|
try {
|
|
final path = await pathForWallet(name: name, type: getType());
|
|
return wownero_wallet_manager.isWalletExist(path: path);
|
|
} catch (e) {
|
|
// TODO: Implement Exception for wallet list service.
|
|
print('WowneroWalletsManager Error: $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<WowneroWallet> openWallet(String name, String password) async {
|
|
WowneroWallet? wallet;
|
|
try {
|
|
final path = await pathForWallet(name: name, type: getType());
|
|
|
|
if (walletFilesExist(path)) {
|
|
await repairOldAndroidWallet(name);
|
|
}
|
|
|
|
await wownero_wallet_manager.openWalletAsync({'path': path, 'password': password});
|
|
final walletInfo = walletInfoSource.values
|
|
.firstWhere((info) => info.id == WalletBase.idFor(name, getType()));
|
|
wallet = WowneroWallet(walletInfo: walletInfo, unspentCoinsInfo: unspentCoinsInfoSource, password: password);
|
|
final isValid = wallet.walletAddresses.validate();
|
|
|
|
if (!isValid) {
|
|
await restoreOrResetWalletFiles(name);
|
|
wallet.close();
|
|
return openWallet(name, password);
|
|
}
|
|
|
|
await wallet.init();
|
|
|
|
return wallet;
|
|
} catch (e, s) {
|
|
// TODO: Implement Exception for wallet list service.
|
|
|
|
final bool isBadAlloc = e.toString().contains('bad_alloc') ||
|
|
(e is WalletOpeningException &&
|
|
(e.message == 'std::bad_alloc' || e.message.contains('bad_alloc')));
|
|
|
|
final bool doesNotCorrespond = e.toString().contains('does not correspond') ||
|
|
(e is WalletOpeningException && e.message.contains('does not correspond'));
|
|
|
|
final bool isMissingCacheFilesIOS = e.toString().contains('basic_string') ||
|
|
(e is WalletOpeningException && e.message.contains('basic_string'));
|
|
|
|
final bool isMissingCacheFilesAndroid = e.toString().contains('input_stream') ||
|
|
e.toString().contains('input stream error') ||
|
|
(e is WalletOpeningException &&
|
|
(e.message.contains('input_stream') || e.message.contains('input stream error')));
|
|
|
|
final bool invalidSignature = e.toString().contains('invalid signature') ||
|
|
(e is WalletOpeningException && e.message.contains('invalid signature'));
|
|
|
|
if (!isBadAlloc &&
|
|
!doesNotCorrespond &&
|
|
!isMissingCacheFilesIOS &&
|
|
!isMissingCacheFilesAndroid &&
|
|
!invalidSignature &&
|
|
wallet != null &&
|
|
wallet.onError != null) {
|
|
wallet.onError!(FlutterErrorDetails(exception: e, stack: s));
|
|
}
|
|
|
|
await restoreOrResetWalletFiles(name);
|
|
return openWallet(name, password);
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<void> remove(String wallet) async {
|
|
final path = await pathForWalletDir(name: wallet, type: getType());
|
|
if (openedWalletsByPath["$path/$wallet"] != null) {
|
|
// NOTE: this is realistically only required on windows.
|
|
print("closing wallet");
|
|
final wmaddr = wmPtr.address;
|
|
final waddr = openedWalletsByPath["$path/$wallet"]!.address;
|
|
// await Isolate.run(() {
|
|
wownero.WalletManager_closeWallet(
|
|
Pointer.fromAddress(wmaddr), Pointer.fromAddress(waddr), false);
|
|
// });
|
|
openedWalletsByPath.remove("$path/$wallet");
|
|
print("wallet closed");
|
|
}
|
|
|
|
final file = Directory(path);
|
|
final isExist = file.existsSync();
|
|
|
|
if (isExist) {
|
|
await file.delete(recursive: true);
|
|
}
|
|
|
|
final walletInfo = walletInfoSource.values
|
|
.firstWhere((info) => info.id == WalletBase.idFor(wallet, getType()));
|
|
await walletInfoSource.delete(walletInfo.key);
|
|
}
|
|
|
|
@override
|
|
Future<void> rename(String currentName, String password, String newName) async {
|
|
final currentWalletInfo = walletInfoSource.values
|
|
.firstWhere((info) => info.id == WalletBase.idFor(currentName, getType()));
|
|
final currentWallet =
|
|
WowneroWallet(walletInfo: currentWalletInfo, unspentCoinsInfo: unspentCoinsInfoSource, password: password);
|
|
|
|
await currentWallet.renameWalletFiles(newName);
|
|
|
|
final newWalletInfo = currentWalletInfo;
|
|
newWalletInfo.id = WalletBase.idFor(newName, getType());
|
|
newWalletInfo.name = newName;
|
|
|
|
await walletInfoSource.put(currentWalletInfo.key, newWalletInfo);
|
|
}
|
|
|
|
@override
|
|
Future<WowneroWallet> restoreFromKeys(WowneroRestoreWalletFromKeysCredentials credentials,
|
|
{bool? isTestnet}) async {
|
|
try {
|
|
final path = await pathForWallet(name: credentials.name, type: getType());
|
|
await wownero_wallet_manager.restoreFromKeys(
|
|
path: path,
|
|
password: credentials.password!,
|
|
language: credentials.language,
|
|
restoreHeight: credentials.height!,
|
|
address: credentials.address,
|
|
viewKey: credentials.viewKey,
|
|
spendKey: credentials.spendKey);
|
|
final wallet = WowneroWallet(
|
|
walletInfo: credentials.walletInfo!, unspentCoinsInfo: unspentCoinsInfoSource, password: credentials.password!);
|
|
await wallet.init();
|
|
|
|
return wallet;
|
|
} catch (e) {
|
|
// TODO: Implement Exception for wallet list service.
|
|
print('WowneroWalletsManager Error: $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
@override
|
|
Future<WowneroWallet> restoreFromHardwareWallet(WowneroNewWalletCredentials credentials) {
|
|
throw UnimplementedError(
|
|
"Restoring a Wownero wallet from a hardware wallet is not yet supported!");
|
|
}
|
|
|
|
@override
|
|
Future<WowneroWallet> restoreFromSeed(WowneroRestoreWalletFromSeedCredentials credentials,
|
|
{bool? isTestnet}) async {
|
|
// Restore from Polyseed
|
|
if (Polyseed.isValidSeed(credentials.mnemonic)) {
|
|
return restoreFromPolyseed(credentials);
|
|
}
|
|
|
|
try {
|
|
final path = await pathForWallet(name: credentials.name, type: getType());
|
|
await wownero_wallet_manager.restoreFromSeed(
|
|
path: path,
|
|
password: credentials.password!,
|
|
seed: credentials.mnemonic,
|
|
restoreHeight: credentials.height!);
|
|
final wallet = WowneroWallet(
|
|
walletInfo: credentials.walletInfo!, unspentCoinsInfo: unspentCoinsInfoSource, password: credentials.password!);
|
|
await wallet.init();
|
|
|
|
return wallet;
|
|
} catch (e) {
|
|
// TODO: Implement Exception for wallet list service.
|
|
print('WowneroWalletsManager Error: $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
Future<WowneroWallet> restoreFromPolyseed(
|
|
WowneroRestoreWalletFromSeedCredentials credentials) async {
|
|
try {
|
|
final path = await pathForWallet(name: credentials.name, type: getType());
|
|
final polyseedCoin = PolyseedCoin.POLYSEED_WOWNERO;
|
|
final lang = PolyseedLang.getByPhrase(credentials.mnemonic);
|
|
final polyseed = Polyseed.decode(credentials.mnemonic, lang, polyseedCoin);
|
|
|
|
return _restoreFromPolyseed(
|
|
path, credentials.password!, polyseed, credentials.walletInfo!, lang);
|
|
} catch (e) {
|
|
// TODO: Implement Exception for wallet list service.
|
|
print('WowneroWalletsManager Error: $e');
|
|
rethrow;
|
|
}
|
|
}
|
|
|
|
Future<WowneroWallet> _restoreFromPolyseed(
|
|
String path, String password, Polyseed polyseed, WalletInfo walletInfo, PolyseedLang lang,
|
|
{PolyseedCoin coin = PolyseedCoin.POLYSEED_WOWNERO, int? overrideHeight}) async {
|
|
final height = overrideHeight ??
|
|
getWowneroHeightByDate(date: DateTime.fromMillisecondsSinceEpoch(polyseed.birthday * 1000));
|
|
final spendKey = polyseed.generateKey(coin, 32).toHexString();
|
|
final seed = polyseed.encode(lang, coin);
|
|
|
|
walletInfo.isRecovery = true;
|
|
walletInfo.restoreHeight = height;
|
|
|
|
await wownero_wallet_manager.restoreFromSpendKey(
|
|
path: path,
|
|
password: password,
|
|
seed: seed,
|
|
language: lang.nameEnglish,
|
|
restoreHeight: height,
|
|
spendKey: spendKey);
|
|
|
|
final wallet = WowneroWallet(walletInfo: walletInfo, unspentCoinsInfo: unspentCoinsInfoSource, password: password);
|
|
await wallet.init();
|
|
|
|
return wallet;
|
|
}
|
|
|
|
Future<void> repairOldAndroidWallet(String name) async {
|
|
try {
|
|
if (!Platform.isAndroid) {
|
|
return;
|
|
}
|
|
|
|
final oldAndroidWalletDirPath = await outdatedAndroidPathForWalletDir(name: name);
|
|
final dir = Directory(oldAndroidWalletDirPath);
|
|
|
|
if (!dir.existsSync()) {
|
|
return;
|
|
}
|
|
|
|
final newWalletDirPath = await pathForWalletDir(name: name, type: getType());
|
|
|
|
dir.listSync().forEach((f) {
|
|
final file = File(f.path);
|
|
final name = f.path.split('/').last;
|
|
final newPath = newWalletDirPath + '/$name';
|
|
final newFile = File(newPath);
|
|
|
|
if (!newFile.existsSync()) {
|
|
newFile.createSync();
|
|
}
|
|
newFile.writeAsBytesSync(file.readAsBytesSync());
|
|
});
|
|
} catch (e) {
|
|
print(e.toString());
|
|
}
|
|
}
|
|
}
|