mirror of
https://github.com/cake-tech/cake_wallet.git
synced 2025-04-15 03:41:59 +00:00
cbca4c9c77
* - enabled development options in CI builds. - Implemented caching for account retrieval. - refactor transaction handling in `dashboard_view_model.dart` to improve efficiency and reduce unnecessary updates in xmr. - `DevMoneroCallProfilerPage`, for profiling performance of xmr,wow,zano wallet calls. * use FeatureFlag.hasDevOptions * prevent crashes in monero_c by using mutexes properly improve performance of _transactionDisposer remove unnecessary checks * remove logging, bring back simplified logic * update _transactionDisposer on length and confirmation of first and last transaction * address comments from review * don't throw unhandled exceptions in unawaited async code * use cached transaction list in getAllSubaddresses, fix usage of txHistoryMutex * [DNM] fix: crashes when opening wallet, performance issue when syncing and update dependencies * Revert "use cached transaction list in getAllSubaddresses, fix usage of txHistoryMutex" This reverts commit4c4c33ac6a. * Revert "[DNM] fix: crashes when opening wallet, performance issue when syncing and update dependencies" This reverts commitd7603445ad. * Revert "use cached transaction list in getAllSubaddresses, fix usage of txHistoryMutex" This reverts commit4c4c33ac6a. * update shared_preferences * improve state management performance by not rendering multiple changes in transaction screen on a single frame * fix wallet switching
513 lines
No EOL
19 KiB
Dart
513 lines
No EOL
19 KiB
Dart
import 'dart:convert' as convert;
|
|
import 'dart:ffi';
|
|
import 'dart:io';
|
|
import 'dart:isolate';
|
|
|
|
import 'package:cw_core/transaction_priority.dart';
|
|
import 'package:cw_core/utils/print_verbose.dart';
|
|
import 'package:cw_core/zano_asset.dart';
|
|
import 'package:cw_zano/api/consts.dart';
|
|
import 'package:cw_zano/api/model/asset_id_params.dart';
|
|
import 'package:cw_zano/api/model/create_wallet_result.dart';
|
|
import 'package:cw_zano/api/model/destination.dart';
|
|
import 'package:cw_zano/api/model/get_address_info_result.dart';
|
|
import 'package:cw_zano/api/model/get_recent_txs_and_info_params.dart';
|
|
import 'package:cw_zano/api/model/get_recent_txs_and_info_result.dart';
|
|
import 'package:cw_zano/api/model/get_wallet_info_result.dart';
|
|
import 'package:cw_zano/api/model/get_wallet_status_result.dart';
|
|
import 'package:cw_zano/api/model/proxy_to_daemon_params.dart';
|
|
import 'package:cw_zano/api/model/proxy_to_daemon_result.dart';
|
|
import 'package:cw_zano/api/model/store_result.dart';
|
|
import 'package:cw_zano/api/model/transfer.dart';
|
|
import 'package:cw_zano/api/model/transfer_params.dart';
|
|
import 'package:cw_zano/api/model/transfer_result.dart';
|
|
import 'package:cw_zano/zano_wallet_exceptions.dart';
|
|
import 'package:ffi/ffi.dart';
|
|
import 'package:json_bigint/json_bigint.dart';
|
|
import 'package:monero/zano.dart' as zano;
|
|
import 'package:monero/src/generated_bindings_zano.g.dart' as zanoapi;
|
|
import 'package:path/path.dart' as p;
|
|
|
|
mixin ZanoWalletApi {
|
|
static const _maxReopenAttempts = 5;
|
|
static const _logInfo = false;
|
|
static const int _zanoMixinValue = 10;
|
|
|
|
int _hWallet = 0;
|
|
|
|
int get hWallet => _hWallet;
|
|
|
|
set hWallet(int value) {
|
|
_hWallet = value;
|
|
}
|
|
|
|
int getCurrentTxFee(TransactionPriority priority) => zano.PlainWallet_getCurrentTxFee(priority.raw);
|
|
|
|
void setPassword(String password) => zano.PlainWallet_resetWalletPassword(hWallet, password);
|
|
|
|
void closeWallet(int? walletToClose, {bool force = false}) async {
|
|
printV('close_wallet ${walletToClose ?? hWallet}: $force');
|
|
if (Platform.isWindows || force) {
|
|
final result = await _closeWallet(walletToClose ?? hWallet);
|
|
printV('close_wallet result $result');
|
|
openWalletCache.removeWhere((_, cwr) => cwr.walletId == (walletToClose ?? hWallet));
|
|
}
|
|
}
|
|
|
|
static bool isInit = false;
|
|
|
|
Future<bool> initWallet() async {
|
|
if (isInit) return true;
|
|
final result = zano.PlainWallet_init("", "", 0);
|
|
isInit = true;
|
|
return result == "OK";
|
|
}
|
|
|
|
Future<bool> setupNode(String nodeUrl) async {
|
|
await _setupNode(hWallet, nodeUrl);
|
|
return true;
|
|
}
|
|
|
|
Future<Directory> getWalletDir() async {
|
|
final walletInfoResult = await getWalletInfo();
|
|
return Directory(p.dirname(walletInfoResult.wi.path));
|
|
}
|
|
|
|
Future<File> _getWalletSecretsFile() async {
|
|
final dir = await getWalletDir();
|
|
final file = File(p.join(dir.path, "zano-secrets.json.bin"));
|
|
return file;
|
|
}
|
|
|
|
Future<Map<String, dynamic>> _getSecrets() async {
|
|
final file = await _getWalletSecretsFile();
|
|
if (!file.existsSync()) {
|
|
return {};
|
|
}
|
|
final data = file.readAsBytesSync();
|
|
final b64 = convert.base64.encode(data);
|
|
final respStr = await invokeMethod("decrypt_data", {"buff": "$b64"});
|
|
final resp = convert.json.decode(respStr);
|
|
final dataBytes = convert.base64.decode(resp["result"]["res_buff"] as String);
|
|
final dataStr = convert.utf8.decode(dataBytes);
|
|
final dataObject = convert.json.decode(dataStr);
|
|
return dataObject as Map<String, dynamic>;
|
|
}
|
|
|
|
Future<void> _setSecrets(Map<String, dynamic> data) async {
|
|
final dataStr = convert.json.encode(data);
|
|
final b64 = convert.base64.encode(convert.utf8.encode(dataStr));
|
|
final respStr = await invokeMethod("encrypt_data", {"buff": "$b64"});
|
|
final resp = convert.json.decode(respStr);
|
|
final dataBytes = convert.base64.decode(resp["result"]["res_buff"] as String);
|
|
final file = await _getWalletSecretsFile();
|
|
file.writeAsBytesSync(dataBytes);
|
|
}
|
|
|
|
Future<String?> _getWalletSecret(String key) async {
|
|
final secrets = await _getSecrets();
|
|
return secrets[key] as String?;
|
|
}
|
|
|
|
Future<void> _setWalletSecret(String key, String value) async {
|
|
final secrets = await _getSecrets();
|
|
secrets[key] = value;
|
|
await _setSecrets(secrets);
|
|
}
|
|
|
|
Future<String?> getPassphrase() async {
|
|
return await _getWalletSecret("passphrase");
|
|
}
|
|
|
|
Future<void> setPassphrase(String passphrase) {
|
|
return _setWalletSecret("passphrase", passphrase);
|
|
}
|
|
|
|
Future<String> getSeed() async {
|
|
final passphrase = await getPassphrase();
|
|
final respStr = await invokeMethod("get_restore_info", {"seed_password": passphrase??""});
|
|
final resp = convert.json.decode(respStr);
|
|
return resp["result"]["seed_phrase"] as String;
|
|
}
|
|
|
|
Future<GetWalletInfoResult> getWalletInfo() async {
|
|
final json = await _getWalletInfo(hWallet);
|
|
final result = GetWalletInfoResult.fromJson(jsonDecode(json));
|
|
printV('get_wallet_info got ${result.wi.balances.length} balances: ${result.wi.balances}');
|
|
return result;
|
|
}
|
|
|
|
Future<GetWalletStatusResult> getWalletStatus() async {
|
|
final json = await _getWalletStatus(hWallet);
|
|
if (json == Consts.errorWalletWrongId) {
|
|
printV('wrong wallet id');
|
|
throw ZanoWalletException('Wrong wallet id');
|
|
}
|
|
final status = GetWalletStatusResult.fromJson(jsonDecode(json));
|
|
if (_logInfo)
|
|
printV(
|
|
'get_wallet_status connected: ${status.isDaemonConnected} in refresh: ${status.isInLongRefresh} progress: ${status.progress} wallet state: ${status.walletState} sync: ${status.currentWalletHeight}/${status.currentDaemonHeight} ${(status.currentWalletHeight/status.currentDaemonHeight*100).toStringAsFixed(2)}%');
|
|
return status;
|
|
}
|
|
|
|
Future<String> invokeMethod(String methodName, Object params) async {
|
|
final request = jsonEncode({
|
|
"method": methodName,
|
|
"params": params,
|
|
});
|
|
final invokeResult = await callSyncMethod('invoke', hWallet, request);
|
|
try {
|
|
jsonDecode(invokeResult);
|
|
} catch (e) {
|
|
if (invokeResult.contains(Consts.errorWalletWrongId)) throw ZanoWalletException('Wrong wallet id');
|
|
printV('exception in parsing json in invokeMethod: $invokeResult');
|
|
rethrow;
|
|
}
|
|
return invokeResult;
|
|
}
|
|
|
|
Future<List<ZanoAsset>> getAssetsWhitelist() async {
|
|
try {
|
|
final json = await invokeMethod('assets_whitelist_get', '{}');
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
_checkForErrors(map);
|
|
List<ZanoAsset> assets(String type, bool isGlobalWhitelist) =>
|
|
(map?['result']?[type] as List<dynamic>?)
|
|
?.map((e) => ZanoAsset.fromJson(e as Map<String, dynamic>, isInGlobalWhitelist: isGlobalWhitelist))
|
|
.toList() ??
|
|
[];
|
|
final localWhitelist = assets('local_whitelist', false);
|
|
final globalWhitelist = assets('global_whitelist', true);
|
|
final ownAssets = assets('own_assets', false);
|
|
if (_logInfo)
|
|
printV('assets_whitelist_get got local whitelist: ${localWhitelist.length} ($localWhitelist); '
|
|
'global whitelist: ${globalWhitelist.length} ($globalWhitelist); '
|
|
'own assets: ${ownAssets.length} ($ownAssets)');
|
|
return [...globalWhitelist, ...localWhitelist, ...ownAssets];
|
|
} catch (e) {
|
|
printV('assets_whitelist_get $e');
|
|
return [];
|
|
// rethrow;
|
|
}
|
|
}
|
|
|
|
Future<ZanoAsset?> addAssetsWhitelist(String assetId) async {
|
|
try {
|
|
final json = await invokeMethod('assets_whitelist_add', AssetIdParams(assetId: assetId));
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
_checkForErrors(map);
|
|
if (map!['result']!['status']! == 'OK') {
|
|
final assetDescriptor = ZanoAsset.fromJson(map['result']!['asset_descriptor']! as Map<String, dynamic>);
|
|
printV('assets_whitelist_add added ${assetDescriptor.fullName} ${assetDescriptor.ticker}');
|
|
return assetDescriptor;
|
|
} else {
|
|
printV('assets_whitelist_add status ${map['result']!['status']!}');
|
|
return null;
|
|
}
|
|
} catch (e) {
|
|
printV('assets_whitelist_add $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Future<bool> removeAssetsWhitelist(String assetId) async {
|
|
try {
|
|
final json = await invokeMethod('assets_whitelist_remove', AssetIdParams(assetId: assetId));
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
_checkForErrors(map);
|
|
printV('assets_whitelist_remove status ${map!['result']!['status']!}');
|
|
return (map['result']!['status']! == 'OK');
|
|
} catch (e) {
|
|
printV('assets_whitelist_remove $e');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
Future<ProxyToDaemonResult?> _proxyToDaemon(String uri, String body) async {
|
|
final json = await invokeMethod('proxy_to_daemon', ProxyToDaemonParams(body: body, uri: uri));
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
_checkForErrors(map);
|
|
return ProxyToDaemonResult.fromJson(map!['result'] as Map<String, dynamic>);
|
|
}
|
|
|
|
Future<ZanoAsset?> getAssetInfo(String assetId) async {
|
|
final methodName = 'get_asset_info';
|
|
final params = AssetIdParams(assetId: assetId);
|
|
final result = await _proxyToDaemon('/json_rpc', '{"method": "$methodName","params": ${jsonEncode(params)}}');
|
|
if (result == null) {
|
|
printV('get_asset_info empty result');
|
|
return null;
|
|
}
|
|
final map = jsonDecode(result.body) as Map<String, dynamic>?;
|
|
if (map!['error'] != null) {
|
|
printV('get_asset_info $assetId error ${map['error']!['code']} ${map['error']!['message']}');
|
|
return null;
|
|
} else if (map['result']!['status']! == 'OK') {
|
|
final assetDescriptor = ZanoAsset.fromJson(map['result']!['asset_descriptor']! as Map<String, dynamic>);
|
|
printV('get_asset_info $assetId ${assetDescriptor.fullName} ${assetDescriptor.ticker}');
|
|
return assetDescriptor;
|
|
} else {
|
|
printV('get_asset_info $assetId status ${map['result']!['status']!}');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Future<StoreResult?> store() async {
|
|
try {
|
|
final json = await invokeMethod('store', {});
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
_checkForErrors(map);
|
|
return StoreResult.fromJson(map!['result'] as Map<String, dynamic>);
|
|
} catch (e) {
|
|
printV('store $e');
|
|
return null;
|
|
}
|
|
}
|
|
|
|
Future<GetRecentTxsAndInfoResult> getRecentTxsAndInfo({required int offset, required int count}) async {
|
|
printV('get_recent_txs_and_info $offset $count');
|
|
try {
|
|
final json = await invokeMethod('get_recent_txs_and_info', GetRecentTxsAndInfoParams(offset: offset, count: count));
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
_checkForErrors(map);
|
|
final lastItemIndex = map?['result']?['last_item_index'] as int?;
|
|
final totalTransfers = map?['result']?['total_transfers'] as int?;
|
|
final transfers = map?['result']?['transfers'] as List<dynamic>?;
|
|
if (transfers == null || lastItemIndex == null || totalTransfers == null) {
|
|
printV('get_recent_txs_and_info empty transfers');
|
|
return GetRecentTxsAndInfoResult.empty();
|
|
}
|
|
printV('get_recent_txs_and_info transfers.length: ${transfers.length}');
|
|
return GetRecentTxsAndInfoResult(
|
|
transfers: transfers.map((e) => Transfer.fromJson(e as Map<String, dynamic>)).toList(),
|
|
lastItemIndex: lastItemIndex,
|
|
totalTransfers: totalTransfers,
|
|
);
|
|
} catch (e) {
|
|
printV('get_recent_txs_and_info $e');
|
|
return GetRecentTxsAndInfoResult.empty();
|
|
}
|
|
}
|
|
|
|
GetAddressInfoResult getAddressInfo(String address) => GetAddressInfoResult.fromJson(
|
|
jsonDecode(zano.PlainWallet_getAddressInfo(address)),
|
|
);
|
|
|
|
String _shorten(String s) => s.length > 10 ? '${s.substring(0, 4)}...${s.substring(s.length - 4)}' : s;
|
|
|
|
Future<CreateWalletResult> createWallet(String path, String password) async {
|
|
printV('create_wallet path $path password ${_shorten(password)}');
|
|
final json = zano.PlainWallet_generate(path, password);
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
if (map?['error'] != null) {
|
|
final code = map!['error']?['code'] ?? '';
|
|
final message = map['error']?['message'] ?? '';
|
|
throw ZanoWalletException('Error creating wallet file, $message ($code)');
|
|
}
|
|
if (map?['result'] == null) {
|
|
throw ZanoWalletException('Error creating wallet file, empty response');
|
|
}
|
|
final result = CreateWalletResult.fromJson(map!['result'] as Map<String, dynamic>);
|
|
openWalletCache[path] = result;
|
|
printV('create_wallet ${result.name}');
|
|
return result;
|
|
}
|
|
|
|
Future<CreateWalletResult> restoreWalletFromSeed(String path, String password, String seed, String? passphrase) async {
|
|
printV('restore_wallet path $path');
|
|
final json = zano.PlainWallet_restore(seed, path, password, passphrase??'');
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
if (map?['error'] != null) {
|
|
final code = map!['error']!['code'] ?? '';
|
|
final message = map['error']!['message'] ?? '';
|
|
if (code == Consts.errorWrongSeed) {
|
|
throw RestoreFromSeedsException('Error restoring wallet\nPlease check the seed words are correct. Additionally, if you created this wallet with a passphrase please add it under the Advanced Settings page.');
|
|
} else if (code == Consts.errorAlreadyExists) {
|
|
throw RestoreFromSeedsException('Error restoring wallet, already exists');
|
|
}
|
|
throw RestoreFromSeedsException('Error restoring wallet, $message ($code)');
|
|
}
|
|
if (map?['result'] == null) {
|
|
throw RestoreFromSeedsException('Error restoring wallet, empty response');
|
|
}
|
|
final result = CreateWalletResult.fromJson(map!['result'] as Map<String, dynamic>);
|
|
openWalletCache[path] = result;
|
|
printV('restore_wallet ${result.name} ${result.wi.address}');
|
|
return result;
|
|
}
|
|
|
|
Future<CreateWalletResult> loadWallet(String path, String password, [int attempt = 0]) async {
|
|
printV('load_wallet1 path $path');
|
|
final String json;
|
|
try {
|
|
json = zano.PlainWallet_open(path, password);
|
|
} catch (e) {
|
|
printV('error in loadingWallet $e');
|
|
rethrow;
|
|
}
|
|
|
|
final map = jsonDecode(json) as Map<String, dynamic>?;
|
|
if (map?['error'] != null) {
|
|
final code = map?['error']!['code'] ?? '';
|
|
final message = map?['error']!['message'] ?? '';
|
|
if (code == Consts.errorAlreadyExists && attempt <= _maxReopenAttempts) {
|
|
// already connected to this wallet. closing and trying to reopen
|
|
printV('already connected. closing and reopen wallet (attempt $attempt)');
|
|
closeWallet(attempt, force: true);
|
|
await Future.delayed(const Duration(milliseconds: 500));
|
|
return await loadWallet(path, password, attempt + 1);
|
|
}
|
|
throw ZanoWalletException('Error loading wallet, $message ($code)');
|
|
}
|
|
if (map?['result'] == null) {
|
|
throw ZanoWalletException('Error loading wallet, empty response');
|
|
}
|
|
final result = CreateWalletResult.fromJson(map!['result'] as Map<String, dynamic>);
|
|
printV('load_wallet3 ${result.name} ${result.wi.address}');
|
|
openWalletCache[path] = result;
|
|
return result;
|
|
}
|
|
|
|
static Map<String, CreateWalletResult> openWalletCache = {};
|
|
|
|
Future<TransferResult> transfer(List<Destination> destinations, BigInt fee, String comment) async {
|
|
final params = TransferParams(
|
|
destinations: destinations,
|
|
fee: fee,
|
|
mixin: _zanoMixinValue,
|
|
paymentId: '',
|
|
comment: comment,
|
|
pushPayer: false,
|
|
hideReceiver: true,
|
|
);
|
|
final json = await invokeMethod('transfer', params);
|
|
final map = jsonDecode(json);
|
|
final resultMap = map as Map<String, dynamic>?;
|
|
if (resultMap != null) {
|
|
final transferResultMap = resultMap['result'] as Map<String, dynamic>?;
|
|
if (transferResultMap != null) {
|
|
final transferResult = TransferResult.fromJson(transferResultMap);
|
|
printV('transfer success hash ${transferResult.txHash}');
|
|
return transferResult;
|
|
} else {
|
|
final errorCode = resultMap['error']?['code'];
|
|
final code = errorCode is int ? errorCode.toString() : errorCode as String? ?? '';
|
|
final message = resultMap['error']?['message'] as String? ?? '';
|
|
printV('transfer error $code $message');
|
|
throw TransferException('Transfer error, $message ($code)');
|
|
}
|
|
}
|
|
printV('transfer error empty result');
|
|
throw TransferException('Transfer error, empty result');
|
|
}
|
|
|
|
void _checkForErrors(Map<String, dynamic>? map) {
|
|
if (map == null) {
|
|
throw ZanoWalletException('Empty response');
|
|
}
|
|
final result = map['result'];
|
|
if (result == null) {
|
|
throw ZanoWalletException('Empty response');
|
|
}
|
|
if (result['error'] != null) {
|
|
final code = result['error']!['code'] ?? '';
|
|
final message = result['error']!['message'] ?? '';
|
|
if (code == -1 && message == Consts.errorBusy) {
|
|
throw ZanoWalletBusyException();
|
|
}
|
|
throw ZanoWalletException('Error, $message ($code)');
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
Future<String> callSyncMethod(String methodName, int hWallet, String params) async {
|
|
final params_ = params.toNativeUtf8().address;
|
|
final method_name_ = methodName.toNativeUtf8().address;
|
|
final invokeResult = await Isolate.run(() async {
|
|
final lib = zanoapi.ZanoC(DynamicLibrary.open(zano.libPath));
|
|
final txid = lib.ZANO_PlainWallet_syncCall(
|
|
Pointer.fromAddress(method_name_).cast(),
|
|
hWallet,
|
|
Pointer.fromAddress(params_).cast()
|
|
);
|
|
try {
|
|
final strPtr = txid.cast<Utf8>();
|
|
final str = strPtr.toDartString();
|
|
lib.ZANO_free(strPtr.cast());
|
|
return str;
|
|
} catch (e) {
|
|
return "";
|
|
}
|
|
});
|
|
calloc.free(Pointer.fromAddress(method_name_));
|
|
calloc.free(Pointer.fromAddress(params_));
|
|
return invokeResult;
|
|
}
|
|
|
|
Map<String, dynamic> jsonDecode(String json) {
|
|
try {
|
|
return decodeJson(json.replaceAll("\\/", "/")) as Map<String, dynamic>;
|
|
} catch (e) {
|
|
return convert.jsonDecode(json) as Map<String, dynamic>;
|
|
}
|
|
}
|
|
|
|
String jsonEncode(Object? object) {
|
|
return convert.jsonEncode(object);
|
|
}
|
|
|
|
Future<String> _getWalletStatus(int hWallet) async {
|
|
final jsonPtr = await Isolate.run(() async {
|
|
final lib = zanoapi.ZanoC(DynamicLibrary.open(zano.libPath));
|
|
final status = lib.ZANO_PlainWallet_getWalletStatus(
|
|
hWallet,
|
|
);
|
|
return status.address;
|
|
});
|
|
String json = "";
|
|
try {
|
|
final strPtr = Pointer.fromAddress(jsonPtr).cast<Utf8>();
|
|
final str = strPtr.toDartString();
|
|
zano.ZANO_free(strPtr.cast());
|
|
json = str;
|
|
} catch (e) {
|
|
json = "";
|
|
}
|
|
return json;
|
|
}
|
|
Future<String> _getWalletInfo(int hWallet) async {
|
|
final jsonPtr = await Isolate.run(() async {
|
|
final lib = zanoapi.ZanoC(DynamicLibrary.open(zano.libPath));
|
|
final status = lib.ZANO_PlainWallet_getWalletInfo(
|
|
hWallet,
|
|
);
|
|
return status.address;
|
|
});
|
|
String json = "";
|
|
try {
|
|
final strPtr = Pointer.fromAddress(jsonPtr).cast<Utf8>();
|
|
final str = strPtr.toDartString();
|
|
zano.ZANO_free(strPtr.cast());
|
|
json = str;
|
|
} catch (e) {
|
|
json = "";
|
|
}
|
|
return json;
|
|
}
|
|
|
|
Future<String> _setupNode(int hWallet, String nodeUrl) async {
|
|
await callSyncMethod("reset_connection_url", hWallet, nodeUrl);
|
|
await callSyncMethod("run_wallet", hWallet, "");
|
|
return "OK";
|
|
}
|
|
|
|
Future<String> _closeWallet(int hWallet) async {
|
|
final str = await Isolate.run(() async {
|
|
return zano.PlainWallet_closeWallet(hWallet);
|
|
});
|
|
printV("Closing wallet: $str");
|
|
return str;
|
|
}
|
|
|
|
Map<String, List<int>> debugCallLength() => zano.debugCallLength; |