diff options
Diffstat (limited to 'impls/monero.dart/lib/zano.dart')
| -rw-r--r-- | impls/monero.dart/lib/zano.dart | 688 |
1 files changed, 688 insertions, 0 deletions
diff --git a/impls/monero.dart/lib/zano.dart b/impls/monero.dart/lib/zano.dart new file mode 100644 index 0000000..f17346a --- /dev/null +++ b/impls/monero.dart/lib/zano.dart @@ -0,0 +1,688 @@ + +// ignore_for_file: non_constant_identifier_names, camel_case_types + +import 'dart:ffi'; +import 'dart:io'; + +import 'package:ffi/ffi.dart'; +import 'package:monero/src/generated_bindings_zano.g.dart'; + +export 'src/checksum_monero.dart'; + +typedef PendingTransaction = Pointer<Void>; + +ZanoC? lib; +String libPath = (() { + if (Platform.isWindows) return 'zano_libwallet2_api_c.dll'; + if (Platform.isMacOS) return 'zano_libwallet2_api_c.dylib'; + if (Platform.isIOS) return 'ZanoWallet.framework/ZanoWallet'; + if (Platform.isAndroid) return 'libzano_libwallet2_api_c.so'; + return 'zano_libwallet2_api_c.so'; +})(); + +Map<String, List<int>> debugCallLength = {}; + +final defaultSeparatorStr = ";"; +final defaultSeparator = defaultSeparatorStr.toNativeUtf8().cast<Char>(); +/* we don't call .free here, this comment serves one purpose - so the numbers match :) */ + +final Stopwatch sw = Stopwatch()..start(); + +bool printStarts = false; + +void Function(String call)? debugStart = (call) { + try { + if (printStarts) print("MONERO: $call"); + debugCallLength[call] ??= <int>[]; + debugCallLength[call]!.add(sw.elapsedMicroseconds); + } catch (e) {} +}; +void debugChores() { + for (var key in debugCallLength.keys) { + if (debugCallLength[key]!.length > 1000000) { + final elm = + debugCallLength[key]!.reduce((value, element) => value + element); + debugCallLength[key]!.clear(); + debugCallLength["${key}_1M"] ??= <int>[]; + debugCallLength["${key}_1M"]!.add(elm); + } + } +} + +int debugCount = 0; + +void Function(String call)? debugEnd = (call) { + try { + final id = debugCallLength[call]!.length - 1; + if (++debugCount > 1000000) { + debugCount = 0; + debugChores(); + } + debugCallLength[call]![id] = + sw.elapsedMicroseconds - debugCallLength[call]![id]; + } catch (e) {} +}; +void Function(String call, dynamic error)? errorHandler = (call, error) { + print("$call: $error"); +}; + +// extern ADDAPI const char* ZANO_PlainWallet_init(const char* address, const char* working_dir, int log_level); +String PlainWallet_init(String address, String working_dir, int log_level) { + debugStart?.call('ZANO_PlainWallet_init'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final address_ = address.toNativeUtf8(); + final working_dir_ = working_dir.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_init(address_.cast(), working_dir_.cast(), log_level); + calloc.free(address_); + calloc.free(working_dir_); + debugEnd?.call('ZANO_PlainWallet_init'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_init'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_init', e); + debugEnd?.call('ZANO_PlainWallet_init'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_init2(const char* ip, const char* port, const char* working_dir, int log_level); +String PlainWallet_init2(String ip, String port, String working_dir, int log_level) { + debugStart?.call('ZANO_PlainWallet_init2'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final ip_ = ip.toNativeUtf8(); + final port_ = port.toNativeUtf8(); + final working_dir_ = working_dir.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_init2(ip_.cast(), port_.cast(), working_dir_.cast(), log_level); + calloc.free(ip_); + calloc.free(port_); + calloc.free(working_dir_); + debugEnd?.call('ZANO_PlainWallet_init2'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_init2'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_init2', e); + debugEnd?.call('ZANO_PlainWallet_init2'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_reset(); +String PlainWallet_reset() { + debugStart?.call('ZANO_PlainWallet_reset'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_reset(); + debugEnd?.call('ZANO_PlainWallet_reset'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_reset'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_reset', e); + debugEnd?.call('ZANO_PlainWallet_reset'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_setLogLevel(int log_level); +String PlainWallet_setLogLevel(int log_level) { + debugStart?.call('ZANO_PlainWallet_setLogLevel'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_setLogLevel(log_level); + debugEnd?.call('ZANO_PlainWallet_setLogLevel'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_setLogLevel'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_setLogLevel', e); + debugEnd?.call('ZANO_PlainWallet_setLogLevel'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getVersion(); +String PlainWallet_getVersion() { + debugStart?.call('ZANO_PlainWallet_getVersion'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getVersion(); + debugEnd?.call('ZANO_PlainWallet_getVersion'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getVersion'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getVersion', e); + debugEnd?.call('ZANO_PlainWallet_getVersion'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getWalletFiles(); +String PlainWallet_getWalletFiles() { + debugStart?.call('ZANO_PlainWallet_getWalletFiles'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getWalletFiles(); + debugEnd?.call('ZANO_PlainWallet_getWalletFiles'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getWalletFiles'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getWalletFiles', e); + debugEnd?.call('ZANO_PlainWallet_getWalletFiles'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getExportPrivateInfo(const char* target_dir); +String PlainWallet_getExportPrivateInfo(String target_dir) { + debugStart?.call('ZANO_PlainWallet_getExportPrivateInfo'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final target_dir_ = target_dir.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_getExportPrivateInfo(target_dir_.cast()); + calloc.free(target_dir_); + debugEnd?.call('ZANO_PlainWallet_getExportPrivateInfo'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getExportPrivateInfo'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getExportPrivateInfo', e); + debugEnd?.call('ZANO_PlainWallet_getExportPrivateInfo'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_deleteWallet(const char* file_name); +String PlainWallet_deleteWallet(String file_name) { + debugStart?.call('ZANO_PlainWallet_deleteWallet'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final file_name_ = file_name.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_deleteWallet(file_name_.cast()); + calloc.free(file_name_); + debugEnd?.call('ZANO_PlainWallet_deleteWallet'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_deleteWallet'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_deleteWallet', e); + debugEnd?.call('ZANO_PlainWallet_deleteWallet'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getAddressInfo(const char* addr); +String PlainWallet_getAddressInfo(String addr) { + debugStart?.call('ZANO_PlainWallet_getAddressInfo'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final addr_ = addr.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_getAddressInfo(addr_.cast()); + calloc.free(addr_); + debugEnd?.call('ZANO_PlainWallet_getAddressInfo'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getAddressInfo'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getAddressInfo', e); + debugEnd?.call('ZANO_PlainWallet_getAddressInfo'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getAppconfig(const char* encryption_key); +String PlainWallet_getAppconfig(String encryption_key) { + debugStart?.call('ZANO_PlainWallet_getAppconfig'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final encryption_key_ = encryption_key.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_getAppconfig(encryption_key_.cast()); + calloc.free(encryption_key_); + debugEnd?.call('ZANO_PlainWallet_getAppconfig'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getAppconfig'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getAppconfig', e); + debugEnd?.call('ZANO_PlainWallet_getAppconfig'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_setAppconfig(const char* conf_str, const char* encryption_key); +String PlainWallet_setAppconfig(String conf_str, String encryption_key) { + debugStart?.call('ZANO_PlainWallet_setAppconfig'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final conf_str_ = conf_str.toNativeUtf8(); + final encryption_key_ = encryption_key.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_setAppconfig(conf_str_.cast(), encryption_key_.cast()); + calloc.free(conf_str_); + calloc.free(encryption_key_); + debugEnd?.call('ZANO_PlainWallet_setAppconfig'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_setAppconfig'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_setAppconfig', e); + debugEnd?.call('ZANO_PlainWallet_setAppconfig'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_generateRandomKey(uint64_t lenght); +String PlainWallet_generateRandomKey(int length) { + debugStart?.call('ZANO_PlainWallet_generateRandomKey'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_generateRandomKey(length); + debugEnd?.call('ZANO_PlainWallet_generateRandomKey'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_generateRandomKey'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_generateRandomKey', e); + debugEnd?.call('ZANO_PlainWallet_generateRandomKey'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getLogsBuffer(); +String PlainWallet_getLogsBuffer() { + debugStart?.call('ZANO_PlainWallet_getLogsBuffer'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getLogsBuffer(); + debugEnd?.call('ZANO_PlainWallet_getLogsBuffer'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getLogsBuffer'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getLogsBuffer', e); + debugEnd?.call('ZANO_PlainWallet_getLogsBuffer'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_truncateLog(); +String PlainWallet_truncateLog() { + debugStart?.call('ZANO_PlainWallet_truncateLog'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_truncateLog(); + debugEnd?.call('ZANO_PlainWallet_truncateLog'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_truncateLog'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_truncateLog', e); + debugEnd?.call('ZANO_PlainWallet_truncateLog'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getConnectivityStatus(); +String PlainWallet_getConnectivityStatus() { + debugStart?.call('ZANO_PlainWallet_getConnectivityStatus'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getConnectivityStatus(); + debugEnd?.call('ZANO_PlainWallet_getConnectivityStatus'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getConnectivityStatus'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getConnectivityStatus', e); + debugEnd?.call('ZANO_PlainWallet_getConnectivityStatus'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_open(const char* path, const char* password); +String PlainWallet_open(String path, String password) { + debugStart?.call('ZANO_PlainWallet_open'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final path_ = path.toNativeUtf8(); + final password_ = password.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_open(path_.cast(), password_.cast()); + calloc.free(path_); + calloc.free(password_); + debugEnd?.call('ZANO_PlainWallet_open'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_open'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_open', e); + debugEnd?.call('ZANO_PlainWallet_open'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_restore(const char* seed, const char* path, const char* password, const char* seed_password); +String PlainWallet_restore(String seed, String path, String password, String seed_password) { + debugStart?.call('ZANO_PlainWallet_restore'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final seed_ = seed.toNativeUtf8(); + final path_ = path.toNativeUtf8(); + final password_ = password.toNativeUtf8(); + final seed_password_ = seed_password.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_restore(seed_.cast(), path_.cast(), password_.cast(), seed_password_.cast()); + calloc.free(seed_); + calloc.free(path_); + calloc.free(password_); + calloc.free(seed_password_); + debugEnd?.call('ZANO_PlainWallet_restore'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_restore'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_restore', e); + debugEnd?.call('ZANO_PlainWallet_restore'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_generate(const char* path, const char* password); +String PlainWallet_generate(String path, String password) { + debugStart?.call('ZANO_PlainWallet_generate'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final path_ = path.toNativeUtf8(); + final password_ = password.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_generate(path_.cast(), password_.cast()); + calloc.free(path_); + calloc.free(password_); + debugEnd?.call('ZANO_PlainWallet_generate'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_generate'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_generate', e); + debugEnd?.call('ZANO_PlainWallet_generate'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getOpenWallets(); +String PlainWallet_getOpenWallets() { + debugStart?.call('ZANO_PlainWallet_getOpenWallets'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getOpenWallets(); + debugEnd?.call('ZANO_PlainWallet_getOpenWallets'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getOpenWallets'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getOpenWallets', e); + debugEnd?.call('ZANO_PlainWallet_getOpenWallets'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_getWalletStatus(int64_t h); +String PlainWallet_getWalletStatus(int h) { + debugStart?.call('ZANO_PlainWallet_getWalletStatus'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getWalletStatus(h); + debugEnd?.call('ZANO_PlainWallet_getWalletStatus'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getWalletStatus'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getWalletStatus', e); + debugEnd?.call('ZANO_PlainWallet_getWalletStatus'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_closeWallet(int64_t h); +String PlainWallet_closeWallet(int h) { + debugStart?.call('ZANO_PlainWallet_closeWallet'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_closeWallet(h); + debugEnd?.call('ZANO_PlainWallet_closeWallet'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_closeWallet'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_closeWallet', e); + debugEnd?.call('ZANO_PlainWallet_closeWallet'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_invoke(int64_t h, const char* params); +String PlainWallet_invoke(int h, String params) { + debugStart?.call('ZANO_PlainWallet_invoke'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final params_ = params.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_invoke(h, params_.cast()); + calloc.free(params_); + debugEnd?.call('ZANO_PlainWallet_invoke'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_invoke'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_invoke', e); + debugEnd?.call('ZANO_PlainWallet_invoke'); + return ""; + } +} + +// extern ADDAPI const char* ZANO_PlainWallet_asyncCall(const char* method_name, uint64_t instance_id, const char* params); +String PlainWallet_asyncCall(String method_name, int h, String params) { + debugStart?.call('ZANO_PlainWallet_asyncCall'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final params_ = params.toNativeUtf8(); + final method_name_ = method_name.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_asyncCall(method_name_.cast(), h, params_.cast()); + calloc.free(params_); + calloc.free(method_name_); + debugEnd?.call('ZANO_PlainWallet_asyncCall'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_asyncCall'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_asyncCall', e); + debugEnd?.call('ZANO_PlainWallet_asyncCall'); + return ""; + } +} + +// extern ADDAPI const char* ZANO_PlainWallet_tryPullResult(uint64_t instance_id); +String PlainWallet_tryPullResult(int instance_id) { + debugStart?.call('ZANO_PlainWallet_tryPullResult'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_tryPullResult(instance_id); + debugEnd?.call('ZANO_PlainWallet_tryPullResult'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_tryPullResult'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_tryPullResult', e); + debugEnd?.call('ZANO_PlainWallet_tryPullResult'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_syncCall(const char* method_name, uint64_t instance_id, const char* params); +String PlainWallet_syncCall(String method_name, int instance_id, String params) { + debugStart?.call('ZANO_PlainWallet_syncCall'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final method_name_ = method_name.toNativeUtf8(); + final params_ = params.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_syncCall(method_name_.cast(), instance_id, params_.cast()); + calloc.free(method_name_); + calloc.free(params_); + debugEnd?.call('ZANO_PlainWallet_syncCall'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_syncCall'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_syncCall', e); + debugEnd?.call('ZANO_PlainWallet_syncCall'); + return ""; + } +} +// extern ADDAPI bool ZANO_PlainWallet_isWalletExist(const char* path); +bool PlainWallet_isWalletExist(String path) { + debugStart?.call('ZANO_PlainWallet_isWalletExist'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final path_ = path.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_isWalletExist(path_.cast()); + calloc.free(path_); + debugEnd?.call('ZANO_PlainWallet_isWalletExist'); + return txid; +} +// extern ADDAPI const char* ZANO_PlainWallet_getWalletInfo(int64_t h); +String PlainWallet_getWalletInfo(int h) { + debugStart?.call('ZANO_PlainWallet_getWalletInfo'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getWalletInfo(h); + debugEnd?.call('ZANO_PlainWallet_getWalletInfo'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_getWalletInfo'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_getWalletInfo', e); + debugEnd?.call('ZANO_PlainWallet_getWalletInfo'); + return ""; + } +} +// extern ADDAPI const char* ZANO_PlainWallet_resetWalletPassword(int64_t h, const char* password); +String PlainWallet_resetWalletPassword(int h, String password) { + debugStart?.call('ZANO_PlainWallet_resetWalletPassword'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final password_ = password.toNativeUtf8(); + final txid = lib!.ZANO_PlainWallet_resetWalletPassword(h, password_.cast()); + calloc.free(password_); + debugEnd?.call('ZANO_PlainWallet_resetWalletPassword'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_PlainWallet_resetWalletPassword'); + return str; + } catch (e) { + errorHandler?.call('ZANO_PlainWallet_resetWalletPassword', e); + debugEnd?.call('ZANO_PlainWallet_resetWalletPassword'); + return ""; + } +} +// extern ADDAPI uint64_t ZANO_PlainWallet_getCurrentTxFee(uint64_t priority); +int PlainWallet_getCurrentTxFee(int priority) { + debugStart?.call('ZANO_PlainWallet_getCurrentTxFee'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_PlainWallet_getCurrentTxFee(priority); + debugEnd?.call('ZANO_PlainWallet_getCurrentTxFee'); + return txid; +} + +void ZANO_free(Pointer<Void> wlptr) { + debugStart?.call('ZANO_free'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + + final s = lib!.ZANO_free(wlptr); + debugEnd?.call('ZANO_free'); + return s; +} + +// extern ADDAPI const char* ZANO_checksum_wallet2_api_c_h(); +String checksum_wallet2_api_c_h() { + debugStart?.call('ZANO_checksum_wallet2_api_c_h'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_checksum_wallet2_api_c_h(); + debugEnd?.call('ZANO_checksum_wallet2_api_c_h'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_checksum_wallet2_api_c_h'); + return str; + } catch (e) { + errorHandler?.call('ZANO_checksum_wallet2_api_c_h', e); + debugEnd?.call('ZANO_checksum_wallet2_api_c_h'); + return ""; + } +} +// extern ADDAPI const char* ZANO_checksum_wallet2_api_c_cpp(); +String checksum_wallet2_api_c_cpp() { + debugStart?.call('ZANO_checksum_wallet2_api_c_cpp'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_checksum_wallet2_api_c_cpp(); + debugEnd?.call('ZANO_checksum_wallet2_api_c_cpp'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_checksum_wallet2_api_c_cpp'); + return str; + } catch (e) { + errorHandler?.call('ZANO_checksum_wallet2_api_c_cpp', e); + debugEnd?.call('ZANO_checksum_wallet2_api_c_cpp'); + return ""; + } +} +// extern ADDAPI const char* ZANO_checksum_wallet2_api_c_exp(); +String checksum_wallet2_api_c_exp() { + debugStart?.call('ZANO_checksum_wallet2_api_c_exp'); + lib ??= ZanoC(DynamicLibrary.open(libPath)); + final txid = lib!.ZANO_checksum_wallet2_api_c_exp(); + debugEnd?.call('ZANO_checksum_wallet2_api_c_exp'); + try { + final strPtr = txid.cast<Utf8>(); + final str = strPtr.toDartString(); + ZANO_free(strPtr.cast()); + debugEnd?.call('ZANO_checksum_wallet2_api_c_exp'); + return str; + } catch (e) { + errorHandler?.call('ZANO_checksum_wallet2_api_c_exp', e); + debugEnd?.call('ZANO_checksum_wallet2_api_c_exp'); + return ""; + } +}
\ No newline at end of file |