diff options
Diffstat (limited to 'impls')
29 files changed, 4303 insertions, 833 deletions
diff --git a/impls/monero.dart/ffigen_zano.yaml b/impls/monero.dart/ffigen_zano.yaml new file mode 100644 index 0000000..2c0f6a0 --- /dev/null +++ b/impls/monero.dart/ffigen_zano.yaml @@ -0,0 +1,11 @@ +name: ZanoC +description: monero_c bindings +output: 'lib/src/generated_bindings_zano.g.dart' +headers: + entry-points: + - '../../zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.h' + +exclude-all-by-default: true +functions: + include: + - "ZANO_.+"
\ No newline at end of file diff --git a/impls/monero.dart/lib/monero.dart b/impls/monero.dart/lib/monero.dart index 4fcc970..62264c1 100644 --- a/impls/monero.dart/lib/monero.dart +++ b/impls/monero.dart/lib/monero.dart @@ -2143,23 +2143,6 @@ int Wallet_daemonBlockChainHeight(wallet ptr) { return daemonBlockChainHeight; } -int Wallet_daemonBlockChainHeight_cached(wallet ptr) { - debugStart?.call('MONERO_Wallet_daemonBlockChainHeight_cached'); - lib ??= MoneroC(DynamicLibrary.open(libPath)); - final daemonBlockChainHeight = - lib!.MONERO_Wallet_daemonBlockChainHeight_cached(ptr); - debugEnd?.call('MONERO_Wallet_daemonBlockChainHeight_cached'); - return daemonBlockChainHeight; -} - -void Wallet_daemonBlockChainHeight_runThread(wallet ptr, int seconds) { - debugStart?.call('MONERO_Wallet_daemonBlockChainHeight_enableRefresh'); - lib ??= MoneroC(DynamicLibrary.open(libPath)); - final ret = lib!.MONERO_Wallet_daemonBlockChainHeight_runThread(ptr, seconds); - debugEnd?.call('MONERO_Wallet_daemonBlockChainHeight_enableRefresh'); - return ret; -} - bool Wallet_synchronized(wallet ptr) { debugStart?.call('MONERO_Wallet_synchronized'); lib ??= MoneroC(DynamicLibrary.open(libPath)); @@ -3607,6 +3590,24 @@ bool WalletManager_verifyWalletPassword( return s; } +int WalletManager_queryWalletDevice( + WalletManager wm_ptr, { + required String keysFileName, + required String password, + required int kdfRounds, + }) { + debugStart?.call('MONERO_WalletManager_queryWalletDevice'); + lib ??= MoneroC(DynamicLibrary.open(libPath)); + final keysFileName_ = keysFileName.toNativeUtf8().cast<Char>(); + final password_ = password.toNativeUtf8().cast<Char>(); + final s = lib!.MONERO_WalletManager_queryWalletDevice( + wm_ptr, keysFileName_, password_, kdfRounds); + calloc.free(keysFileName_); + calloc.free(password_); + debugEnd?.call('MONERO_WalletManager_queryWalletDevice'); + return s; +} + List<String> WalletManager_findWallets(WalletManager wm_ptr, {required String path}) { debugStart?.call('MONERO_WalletManager_findWallets'); diff --git a/impls/monero.dart/lib/src/checksum_monero.dart b/impls/monero.dart/lib/src/checksum_monero.dart index 4ab72a3..603eb21 100644 --- a/impls/monero.dart/lib/src/checksum_monero.dart +++ b/impls/monero.dart/lib/src/checksum_monero.dart @@ -1,4 +1,4 @@ // ignore_for_file: constant_identifier_names -const String wallet2_api_c_h_sha256 = "e8db0ef0324a153f5e3ecca4c0db23c54f4576e84988f04bd4f11c1142f9d7ad"; -const String wallet2_api_c_cpp_sha256 = "dca52ac9ee009fda9fb5726543a454885e61d8eb74fb33112288029ed625bec5-b089f9ee69924882c5d14dd1a6991deb05d9d1cd"; -const String wallet2_api_c_exp_sha256 = "c8913ac41068f67b57c9b0a3c7dd8973e3c1273b66c2ff0aadb0003931da748c"; +const String wallet2_api_c_h_sha256 = "9e80c4b59a0509aa02fbf01e8df2881b89f82225d1765bfa7856cbdbaf7af116"; +const String wallet2_api_c_cpp_sha256 = "d229507db508e574bd2badf4819a38dbead8c16a84311ad32c22c887a6003439-b089f9ee69924882c5d14dd1a6991deb05d9d1cd"; +const String wallet2_api_c_exp_sha256 = "d0f95f1f3bc49f1f59fe4eb0b61826128d7d3bb75405d5a01a252d02db03097d"; diff --git a/impls/monero.dart/lib/src/checksum_wownero.dart b/impls/monero.dart/lib/src/checksum_wownero.dart index 7d501c6..bada1f4 100644 --- a/impls/monero.dart/lib/src/checksum_wownero.dart +++ b/impls/monero.dart/lib/src/checksum_wownero.dart @@ -1,4 +1,4 @@ // ignore_for_file: constant_identifier_names -const String wallet2_api_c_h_sha256 = "8a8d386dd5d996c89a0586c55b295ef95ca584bf1ffa26255152b291910a0a77"; -const String wallet2_api_c_cpp_sha256 = "07d67f34a07869aaa4af6ca04e142dbad2fb1fba0e2ebdefd22bc333fd982e25-e25963cbc11ca0a0fe5eb34b9bd7c72e4f51b795"; -const String wallet2_api_c_exp_sha256 = "3673e40e1a7115552276d1d541f6e4d5a0fef47c40fff7b988f49923af84c8a4"; +const String wallet2_api_c_h_sha256 = "f99009d1ca1d1c783cc9aa0fb63f680d48753b88124fb5de2079c57b7e34c827"; +const String wallet2_api_c_cpp_sha256 = "70b39a0bef660cb9ba0397117eb1590e18461ace89ab18141690658a2a537d5d-dd46a31f3cab67b316e9239b15acf7d5cea60aa9"; +const String wallet2_api_c_exp_sha256 = "5f53ea8bbe66a5e5aa6cbc4ca00695900e08589cfd32062e88965a24252d05ba"; diff --git a/impls/monero.dart/lib/src/checksum_zano.dart b/impls/monero.dart/lib/src/checksum_zano.dart new file mode 100644 index 0000000..b8b879a --- /dev/null +++ b/impls/monero.dart/lib/src/checksum_zano.dart @@ -0,0 +1,4 @@ +// ignore_for_file: constant_identifier_names +const String wallet2_api_c_h_sha256 = "8acaa95513b85a984c08e05cc3f2ac7530bb8f32946eeeb45357bd846aef33dd"; +const String wallet2_api_c_cpp_sha256 = "4efacd3812d53dd268b6869cc0a9560e7320574d96e09136cf067f796edfeba6-2817090c8ac7639d6f697d00fc8bcba2b3681d90"; +const String wallet2_api_c_exp_sha256 = "66f3ff655bbfd11ad28c318ab707090b5a93276f436b06f7b1c0f329dba3c9c2"; diff --git a/impls/monero.dart/lib/src/generated_bindings_monero.g.dart b/impls/monero.dart/lib/src/generated_bindings_monero.g.dart index 039fbf9..77e2899 100644 --- a/impls/monero.dart/lib/src/generated_bindings_monero.g.dart +++ b/impls/monero.dart/lib/src/generated_bindings_monero.g.dart @@ -2763,39 +2763,6 @@ class MoneroC { _MONERO_Wallet_daemonBlockChainHeightPtr.asFunction< int Function(ffi.Pointer<ffi.Void>)>(); - int MONERO_Wallet_daemonBlockChainHeight_cached( - ffi.Pointer<ffi.Void> wallet_ptr, - ) { - return _MONERO_Wallet_daemonBlockChainHeight_cached( - wallet_ptr, - ); - } - - late final _MONERO_Wallet_daemonBlockChainHeight_cachedPtr = - _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>( - 'MONERO_Wallet_daemonBlockChainHeight_cached'); - late final _MONERO_Wallet_daemonBlockChainHeight_cached = - _MONERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction< - int Function(ffi.Pointer<ffi.Void>)>(); - - void MONERO_Wallet_daemonBlockChainHeight_runThread( - ffi.Pointer<ffi.Void> wallet_ptr, - int seconds, - ) { - return _MONERO_Wallet_daemonBlockChainHeight_runThread( - wallet_ptr, - seconds, - ); - } - - late final _MONERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup< - ffi - .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>( - 'MONERO_Wallet_daemonBlockChainHeight_runThread'); - late final _MONERO_Wallet_daemonBlockChainHeight_runThread = - _MONERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction< - void Function(ffi.Pointer<ffi.Void>, int)>(); - int MONERO_Wallet_daemonBlockChainTargetHeight( ffi.Pointer<ffi.Void> wallet_ptr, ) { @@ -4911,14 +4878,14 @@ class MoneroC { bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>(); - bool MONERO_WalletManager_queryWalletDevice( - int device_type, + int MONERO_WalletManager_queryWalletDevice( + ffi.Pointer<ffi.Void> wm_ptr, ffi.Pointer<ffi.Char> keys_file_name, ffi.Pointer<ffi.Char> password, int kdf_rounds, ) { return _MONERO_WalletManager_queryWalletDevice( - device_type, + wm_ptr, keys_file_name, password, kdf_rounds, @@ -4927,15 +4894,15 @@ class MoneroC { late final _MONERO_WalletManager_queryWalletDevicePtr = _lookup< ffi.NativeFunction< - ffi.Bool Function( - ffi.Int, + ffi.Int Function( + ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, ffi.Uint64)>>('MONERO_WalletManager_queryWalletDevice'); late final _MONERO_WalletManager_queryWalletDevice = _MONERO_WalletManager_queryWalletDevicePtr.asFunction< - bool Function( - int, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>(); + int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, int)>(); ffi.Pointer<ffi.Char> MONERO_WalletManager_findWallets( ffi.Pointer<ffi.Void> wm_ptr, diff --git a/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart b/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart index 2fe1eef..b7d1321 100644 --- a/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart +++ b/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart @@ -2740,39 +2740,6 @@ class WowneroC { _WOWNERO_Wallet_daemonBlockChainHeightPtr.asFunction< int Function(ffi.Pointer<ffi.Void>)>(); - int WOWNERO_Wallet_daemonBlockChainHeight_cached( - ffi.Pointer<ffi.Void> wallet_ptr, - ) { - return _WOWNERO_Wallet_daemonBlockChainHeight_cached( - wallet_ptr, - ); - } - - late final _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr = - _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>( - 'WOWNERO_Wallet_daemonBlockChainHeight_cached'); - late final _WOWNERO_Wallet_daemonBlockChainHeight_cached = - _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction< - int Function(ffi.Pointer<ffi.Void>)>(); - - void WOWNERO_Wallet_daemonBlockChainHeight_runThread( - ffi.Pointer<ffi.Void> wallet_ptr, - int seconds, - ) { - return _WOWNERO_Wallet_daemonBlockChainHeight_runThread( - wallet_ptr, - seconds, - ); - } - - late final _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup< - ffi - .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>( - 'WOWNERO_Wallet_daemonBlockChainHeight_runThread'); - late final _WOWNERO_Wallet_daemonBlockChainHeight_runThread = - _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction< - void Function(ffi.Pointer<ffi.Void>, int)>(); - int WOWNERO_Wallet_daemonBlockChainTargetHeight( ffi.Pointer<ffi.Void> wallet_ptr, ) { diff --git a/impls/monero.dart/lib/src/generated_bindings_zano.g.dart b/impls/monero.dart/lib/src/generated_bindings_zano.g.dart new file mode 100644 index 0000000..1ffdc3e --- /dev/null +++ b/impls/monero.dart/lib/src/generated_bindings_zano.g.dart @@ -0,0 +1,527 @@ +// AUTO GENERATED FILE, DO NOT EDIT. +// +// Generated by `package:ffigen`. +// ignore_for_file: type=lint +import 'dart:ffi' as ffi; + +/// monero_c bindings +class ZanoC { + /// Holds the symbol lookup function. + final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) + _lookup; + + /// The symbols are looked up in [dynamicLibrary]. + ZanoC(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup; + + /// The symbols are looked up with [lookup]. + ZanoC.fromLookup( + ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName) + lookup) + : _lookup = lookup; + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_init( + ffi.Pointer<ffi.Char> address, + ffi.Pointer<ffi.Char> working_dir, + int log_level, + ) { + return _ZANO_PlainWallet_init( + address, + working_dir, + log_level, + ); + } + + late final _ZANO_PlainWallet_initPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, ffi.Int)>>('ZANO_PlainWallet_init'); + late final _ZANO_PlainWallet_init = _ZANO_PlainWallet_initPtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_init2( + ffi.Pointer<ffi.Char> ip, + ffi.Pointer<ffi.Char> port, + ffi.Pointer<ffi.Char> working_dir, + int log_level, + ) { + return _ZANO_PlainWallet_init2( + ip, + port, + working_dir, + log_level, + ); + } + + late final _ZANO_PlainWallet_init2Ptr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, + ffi.Int)>>('ZANO_PlainWallet_init2'); + late final _ZANO_PlainWallet_init2 = _ZANO_PlainWallet_init2Ptr.asFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_reset() { + return _ZANO_PlainWallet_reset(); + } + + late final _ZANO_PlainWallet_resetPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_reset'); + late final _ZANO_PlainWallet_reset = + _ZANO_PlainWallet_resetPtr.asFunction<ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_setLogLevel( + int log_level, + ) { + return _ZANO_PlainWallet_setLogLevel( + log_level, + ); + } + + late final _ZANO_PlainWallet_setLogLevelPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int)>>( + 'ZANO_PlainWallet_setLogLevel'); + late final _ZANO_PlainWallet_setLogLevel = _ZANO_PlainWallet_setLogLevelPtr + .asFunction<ffi.Pointer<ffi.Char> Function(int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getVersion() { + return _ZANO_PlainWallet_getVersion(); + } + + late final _ZANO_PlainWallet_getVersionPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_getVersion'); + late final _ZANO_PlainWallet_getVersion = _ZANO_PlainWallet_getVersionPtr + .asFunction<ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getWalletFiles() { + return _ZANO_PlainWallet_getWalletFiles(); + } + + late final _ZANO_PlainWallet_getWalletFilesPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_getWalletFiles'); + late final _ZANO_PlainWallet_getWalletFiles = + _ZANO_PlainWallet_getWalletFilesPtr.asFunction< + ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getExportPrivateInfo( + ffi.Pointer<ffi.Char> target_dir, + ) { + return _ZANO_PlainWallet_getExportPrivateInfo( + target_dir, + ); + } + + late final _ZANO_PlainWallet_getExportPrivateInfoPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_getExportPrivateInfo'); + late final _ZANO_PlainWallet_getExportPrivateInfo = + _ZANO_PlainWallet_getExportPrivateInfoPtr.asFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_deleteWallet( + ffi.Pointer<ffi.Char> file_name, + ) { + return _ZANO_PlainWallet_deleteWallet( + file_name, + ); + } + + late final _ZANO_PlainWallet_deleteWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_deleteWallet'); + late final _ZANO_PlainWallet_deleteWallet = _ZANO_PlainWallet_deleteWalletPtr + .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getAddressInfo( + ffi.Pointer<ffi.Char> addr, + ) { + return _ZANO_PlainWallet_getAddressInfo( + addr, + ); + } + + late final _ZANO_PlainWallet_getAddressInfoPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_getAddressInfo'); + late final _ZANO_PlainWallet_getAddressInfo = + _ZANO_PlainWallet_getAddressInfoPtr.asFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getAppconfig( + ffi.Pointer<ffi.Char> encryption_key, + ) { + return _ZANO_PlainWallet_getAppconfig( + encryption_key, + ); + } + + late final _ZANO_PlainWallet_getAppconfigPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_getAppconfig'); + late final _ZANO_PlainWallet_getAppconfig = _ZANO_PlainWallet_getAppconfigPtr + .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_setAppconfig( + ffi.Pointer<ffi.Char> conf_str, + ffi.Pointer<ffi.Char> encryption_key, + ) { + return _ZANO_PlainWallet_setAppconfig( + conf_str, + encryption_key, + ); + } + + late final _ZANO_PlainWallet_setAppconfigPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_setAppconfig'); + late final _ZANO_PlainWallet_setAppconfig = + _ZANO_PlainWallet_setAppconfigPtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_generateRandomKey( + int lenght, + ) { + return _ZANO_PlainWallet_generateRandomKey( + lenght, + ); + } + + late final _ZANO_PlainWallet_generateRandomKeyPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Uint64)>>( + 'ZANO_PlainWallet_generateRandomKey'); + late final _ZANO_PlainWallet_generateRandomKey = + _ZANO_PlainWallet_generateRandomKeyPtr.asFunction< + ffi.Pointer<ffi.Char> Function(int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getLogsBuffer() { + return _ZANO_PlainWallet_getLogsBuffer(); + } + + late final _ZANO_PlainWallet_getLogsBufferPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_getLogsBuffer'); + late final _ZANO_PlainWallet_getLogsBuffer = + _ZANO_PlainWallet_getLogsBufferPtr.asFunction< + ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_truncateLog() { + return _ZANO_PlainWallet_truncateLog(); + } + + late final _ZANO_PlainWallet_truncateLogPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_truncateLog'); + late final _ZANO_PlainWallet_truncateLog = _ZANO_PlainWallet_truncateLogPtr + .asFunction<ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getConnectivityStatus() { + return _ZANO_PlainWallet_getConnectivityStatus(); + } + + late final _ZANO_PlainWallet_getConnectivityStatusPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_getConnectivityStatus'); + late final _ZANO_PlainWallet_getConnectivityStatus = + _ZANO_PlainWallet_getConnectivityStatusPtr.asFunction< + ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_open( + ffi.Pointer<ffi.Char> path, + ffi.Pointer<ffi.Char> password, + ) { + return _ZANO_PlainWallet_open( + path, + password, + ); + } + + late final _ZANO_PlainWallet_openPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_open'); + late final _ZANO_PlainWallet_open = _ZANO_PlainWallet_openPtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_restore( + ffi.Pointer<ffi.Char> seed, + ffi.Pointer<ffi.Char> path, + ffi.Pointer<ffi.Char> password, + ffi.Pointer<ffi.Char> seed_password, + ) { + return _ZANO_PlainWallet_restore( + seed, + path, + password, + seed_password, + ); + } + + late final _ZANO_PlainWallet_restorePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_restore'); + late final _ZANO_PlainWallet_restore = + _ZANO_PlainWallet_restorePtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_generate( + ffi.Pointer<ffi.Char> path, + ffi.Pointer<ffi.Char> password, + ) { + return _ZANO_PlainWallet_generate( + path, + password, + ); + } + + late final _ZANO_PlainWallet_generatePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_generate'); + late final _ZANO_PlainWallet_generate = + _ZANO_PlainWallet_generatePtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getOpenWallets() { + return _ZANO_PlainWallet_getOpenWallets(); + } + + late final _ZANO_PlainWallet_getOpenWalletsPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_PlainWallet_getOpenWallets'); + late final _ZANO_PlainWallet_getOpenWallets = + _ZANO_PlainWallet_getOpenWalletsPtr.asFunction< + ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getWalletStatus( + int h, + ) { + return _ZANO_PlainWallet_getWalletStatus( + h, + ); + } + + late final _ZANO_PlainWallet_getWalletStatusPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int64)>>( + 'ZANO_PlainWallet_getWalletStatus'); + late final _ZANO_PlainWallet_getWalletStatus = + _ZANO_PlainWallet_getWalletStatusPtr.asFunction< + ffi.Pointer<ffi.Char> Function(int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_closeWallet( + int h, + ) { + return _ZANO_PlainWallet_closeWallet( + h, + ); + } + + late final _ZANO_PlainWallet_closeWalletPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int64)>>( + 'ZANO_PlainWallet_closeWallet'); + late final _ZANO_PlainWallet_closeWallet = _ZANO_PlainWallet_closeWalletPtr + .asFunction<ffi.Pointer<ffi.Char> Function(int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_invoke( + int h, + ffi.Pointer<ffi.Char> params, + ) { + return _ZANO_PlainWallet_invoke( + h, + params, + ); + } + + late final _ZANO_PlainWallet_invokePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Int64, ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_invoke'); + late final _ZANO_PlainWallet_invoke = _ZANO_PlainWallet_invokePtr.asFunction< + ffi.Pointer<ffi.Char> Function(int, ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_asyncCall( + ffi.Pointer<ffi.Char> method_name, + int instance_id, + ffi.Pointer<ffi.Char> params, + ) { + return _ZANO_PlainWallet_asyncCall( + method_name, + instance_id, + params, + ); + } + + late final _ZANO_PlainWallet_asyncCallPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, ffi.Uint64, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_asyncCall'); + late final _ZANO_PlainWallet_asyncCall = + _ZANO_PlainWallet_asyncCallPtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_tryPullResult( + int instance_id, + ) { + return _ZANO_PlainWallet_tryPullResult( + instance_id, + ); + } + + late final _ZANO_PlainWallet_tryPullResultPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Uint64)>>( + 'ZANO_PlainWallet_tryPullResult'); + late final _ZANO_PlainWallet_tryPullResult = + _ZANO_PlainWallet_tryPullResultPtr.asFunction< + ffi.Pointer<ffi.Char> Function(int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_syncCall( + ffi.Pointer<ffi.Char> method_name, + int instance_id, + ffi.Pointer<ffi.Char> params, + ) { + return _ZANO_PlainWallet_syncCall( + method_name, + instance_id, + params, + ); + } + + late final _ZANO_PlainWallet_syncCallPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, ffi.Uint64, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_syncCall'); + late final _ZANO_PlainWallet_syncCall = + _ZANO_PlainWallet_syncCallPtr.asFunction< + ffi.Pointer<ffi.Char> Function( + ffi.Pointer<ffi.Char>, int, ffi.Pointer<ffi.Char>)>(); + + bool ZANO_PlainWallet_isWalletExist( + ffi.Pointer<ffi.Char> path, + ) { + return _ZANO_PlainWallet_isWalletExist( + path, + ); + } + + late final _ZANO_PlainWallet_isWalletExistPtr = + _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>)>>( + 'ZANO_PlainWallet_isWalletExist'); + late final _ZANO_PlainWallet_isWalletExist = + _ZANO_PlainWallet_isWalletExistPtr.asFunction< + bool Function(ffi.Pointer<ffi.Char>)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_getWalletInfo( + int h, + ) { + return _ZANO_PlainWallet_getWalletInfo( + h, + ); + } + + late final _ZANO_PlainWallet_getWalletInfoPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Int64)>>( + 'ZANO_PlainWallet_getWalletInfo'); + late final _ZANO_PlainWallet_getWalletInfo = + _ZANO_PlainWallet_getWalletInfoPtr.asFunction< + ffi.Pointer<ffi.Char> Function(int)>(); + + ffi.Pointer<ffi.Char> ZANO_PlainWallet_resetWalletPassword( + int h, + ffi.Pointer<ffi.Char> password, + ) { + return _ZANO_PlainWallet_resetWalletPassword( + h, + password, + ); + } + + late final _ZANO_PlainWallet_resetWalletPasswordPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer<ffi.Char> Function(ffi.Int64, + ffi.Pointer<ffi.Char>)>>('ZANO_PlainWallet_resetWalletPassword'); + late final _ZANO_PlainWallet_resetWalletPassword = + _ZANO_PlainWallet_resetWalletPasswordPtr.asFunction< + ffi.Pointer<ffi.Char> Function(int, ffi.Pointer<ffi.Char>)>(); + + int ZANO_PlainWallet_getCurrentTxFee( + int priority, + ) { + return _ZANO_PlainWallet_getCurrentTxFee( + priority, + ); + } + + late final _ZANO_PlainWallet_getCurrentTxFeePtr = + _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Uint64)>>( + 'ZANO_PlainWallet_getCurrentTxFee'); + late final _ZANO_PlainWallet_getCurrentTxFee = + _ZANO_PlainWallet_getCurrentTxFeePtr.asFunction<int Function(int)>(); + + void ZANO_free( + ffi.Pointer<ffi.Void> ptr, + ) { + return _ZANO_free( + ptr, + ); + } + + late final _ZANO_freePtr = + _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>( + 'ZANO_free'); + late final _ZANO_free = + _ZANO_freePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>(); + + ffi.Pointer<ffi.Char> ZANO_checksum_wallet2_api_c_h() { + return _ZANO_checksum_wallet2_api_c_h(); + } + + late final _ZANO_checksum_wallet2_api_c_hPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_checksum_wallet2_api_c_h'); + late final _ZANO_checksum_wallet2_api_c_h = _ZANO_checksum_wallet2_api_c_hPtr + .asFunction<ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_checksum_wallet2_api_c_cpp() { + return _ZANO_checksum_wallet2_api_c_cpp(); + } + + late final _ZANO_checksum_wallet2_api_c_cppPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_checksum_wallet2_api_c_cpp'); + late final _ZANO_checksum_wallet2_api_c_cpp = + _ZANO_checksum_wallet2_api_c_cppPtr.asFunction< + ffi.Pointer<ffi.Char> Function()>(); + + ffi.Pointer<ffi.Char> ZANO_checksum_wallet2_api_c_exp() { + return _ZANO_checksum_wallet2_api_c_exp(); + } + + late final _ZANO_checksum_wallet2_api_c_expPtr = + _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>( + 'ZANO_checksum_wallet2_api_c_exp'); + late final _ZANO_checksum_wallet2_api_c_exp = + _ZANO_checksum_wallet2_api_c_expPtr.asFunction< + ffi.Pointer<ffi.Char> Function()>(); +} diff --git a/impls/monero.dart/lib/wownero.dart b/impls/monero.dart/lib/wownero.dart index d355005..56bd43e 100644 --- a/impls/monero.dart/lib/wownero.dart +++ b/impls/monero.dart/lib/wownero.dart @@ -2108,24 +2108,6 @@ int Wallet_daemonBlockChainHeight(wallet ptr) { return daemonBlockChainHeight; } -int Wallet_daemonBlockChainHeight_cached(wallet ptr) { - debugStart?.call('WOWNERO_Wallet_daemonBlockChainHeight_cached'); - lib ??= WowneroC(DynamicLibrary.open(libPath)); - final daemonBlockChainHeight = - lib!.WOWNERO_Wallet_daemonBlockChainHeight_cached(ptr); - debugEnd?.call('WOWNERO_Wallet_daemonBlockChainHeight_cached'); - return daemonBlockChainHeight; -} - -void Wallet_daemonBlockChainHeight_runThread(wallet ptr, int seconds) { - debugStart?.call('WOWNERO_Wallet_daemonBlockChainHeight_enableRefresh'); - lib ??= WowneroC(DynamicLibrary.open(libPath)); - final ret = - lib!.WOWNERO_Wallet_daemonBlockChainHeight_runThread(ptr, seconds); - debugEnd?.call('WOWNERO_Wallet_daemonBlockChainHeight_enableRefresh'); - return ret; -} - bool Wallet_synchronized(wallet ptr) { debugStart?.call('WOWNERO_Wallet_synchronized'); lib ??= WowneroC(DynamicLibrary.open(libPath)); 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 diff --git a/impls/monero.dart/pubspec.yaml b/impls/monero.dart/pubspec.yaml index 174a781..2a32efe 100644 --- a/impls/monero.dart/pubspec.yaml +++ b/impls/monero.dart/pubspec.yaml @@ -12,4 +12,4 @@ dependencies: dev_dependencies: lints: ^5.0.0 test: ^1.24.0 - ffigen: ^14.0.0
\ No newline at end of file + ffigen: ^14.0.0 diff --git a/impls/monero.dart/update_bindings.sh b/impls/monero.dart/update_bindings.sh index 8ac3cab..f1ba024 100755 --- a/impls/monero.dart/update_bindings.sh +++ b/impls/monero.dart/update_bindings.sh @@ -6,3 +6,4 @@ cd "$(realpath $(dirname $0))" dart run ffigen --config ffigen_wownero.yaml dart run ffigen --config ffigen_monero.yaml +dart run ffigen --config ffigen_zano.yaml diff --git a/impls/monero.ts/README.md b/impls/monero.ts/README.md index fe06467..9e3b27a 100644 --- a/impls/monero.ts/README.md +++ b/impls/monero.ts/README.md @@ -23,7 +23,7 @@ There are at least two ways to do so: loadMoneroDylib(); const wm = await WalletManager.new(); - const wallet = await Wallet.create(wm, "./my_wallet", "password"); + const wallet = await wm.createWallet("./my_wallet", "password"); console.log(await wallet.address()); @@ -41,7 +41,7 @@ There are at least two ways to do so: loadMoneroDylib(lib); const wm = await WalletManager.new(); - const wallet = await Wallet.create(wm, "./my_wallet", "password"); + const wallet = await wm.createWallet("./my_wallet", "password"); console.log(await wallet.address()); diff --git a/impls/monero.ts/checksum.ts b/impls/monero.ts/checksum.ts index b0d12b0..81140d3 100644 --- a/impls/monero.ts/checksum.ts +++ b/impls/monero.ts/checksum.ts @@ -1,6 +1,6 @@ import { moneroChecksum } from "./checksum_monero.ts"; -import { getSymbol, readCString } from "./src/utils.ts"; -import { dylib, loadMoneroDylib } from "./src/bindings.ts"; +import { readCString } from "./src/utils.ts"; +import { fns, loadMoneroDylib } from "./src/bindings.ts"; loadMoneroDylib(); @@ -21,7 +21,7 @@ export class ChecksumError extends Error { * @returns {ChecksumError} which contains information about why checksum failed */ export async function validateChecksum(): Promise<ChecksumError | null> { - const cppHeaderHash = await readCString(await getSymbol("checksum_wallet2_api_c_h")!(), false); + const cppHeaderHash = await readCString(await fns.checksum_wallet2_api_c_h!(), false); const tsHeaderHash = moneroChecksum.wallet2_api_c_h_sha256; const errors: string[] = []; @@ -32,14 +32,14 @@ export async function validateChecksum(): Promise<ChecksumError | null> { errorCode++; } - const cppSourceHash = await readCString(await getSymbol("checksum_wallet2_api_c_cpp")!(), false); + const cppSourceHash = await readCString(await fns.checksum_wallet2_api_c_cpp!(), false); const tsSourceHash = moneroChecksum.wallet2_api_c_cpp_sha256; if (cppSourceHash !== tsSourceHash) { errors.push(`ERR: CPP source file check mismatch ${cppSourceHash} == ${tsSourceHash}`); errorCode++; } - const cppExportHash = await readCString(await getSymbol("checksum_wallet2_api_c_exp")!(), false); + const cppExportHash = await readCString(await fns.checksum_wallet2_api_c_exp!(), false); const tsExportHash = moneroChecksum.wallet2_api_c_exp_sha256; if (cppExportHash !== tsExportHash) { if (Deno.build.os !== "darwin") { diff --git a/impls/monero.ts/checksum_monero.ts b/impls/monero.ts/checksum_monero.ts index 88406a0..03bb061 100644 --- a/impls/monero.ts/checksum_monero.ts +++ b/impls/monero.ts/checksum_monero.ts @@ -1,5 +1,5 @@ export const moneroChecksum = { - wallet2_api_c_h_sha256: "e8db0ef0324a153f5e3ecca4c0db23c54f4576e84988f04bd4f11c1142f9d7ad", - wallet2_api_c_cpp_sha256: "dca52ac9ee009fda9fb5726543a454885e61d8eb74fb33112288029ed625bec5-b089f9ee69924882c5d14dd1a6991deb05d9d1cd", - wallet2_api_c_exp_sha256: "c8913ac41068f67b57c9b0a3c7dd8973e3c1273b66c2ff0aadb0003931da748c", + wallet2_api_c_h_sha256: "9e80c4b59a0509aa02fbf01e8df2881b89f82225d1765bfa7856cbdbaf7af116", + wallet2_api_c_cpp_sha256: "d229507db508e574bd2badf4819a38dbead8c16a84311ad32c22c887a6003439-b089f9ee69924882c5d14dd1a6991deb05d9d1cd", + wallet2_api_c_exp_sha256: "d0f95f1f3bc49f1f59fe4eb0b61826128d7d3bb75405d5a01a252d02db03097d", } diff --git a/impls/monero.ts/checksum_wownero.ts b/impls/monero.ts/checksum_wownero.ts index 8b2899c..7e0c8cd 100644 --- a/impls/monero.ts/checksum_wownero.ts +++ b/impls/monero.ts/checksum_wownero.ts @@ -1,5 +1,5 @@ export const wowneroChecksum = { - wallet2_api_c_h_sha256: "8a8d386dd5d996c89a0586c55b295ef95ca584bf1ffa26255152b291910a0a77", - wallet2_api_c_cpp_sha256: "07d67f34a07869aaa4af6ca04e142dbad2fb1fba0e2ebdefd22bc333fd982e25-e25963cbc11ca0a0fe5eb34b9bd7c72e4f51b795", - wallet2_api_c_exp_sha256: "3673e40e1a7115552276d1d541f6e4d5a0fef47c40fff7b988f49923af84c8a4", + wallet2_api_c_h_sha256: "f99009d1ca1d1c783cc9aa0fb63f680d48753b88124fb5de2079c57b7e34c827", + wallet2_api_c_cpp_sha256: "70b39a0bef660cb9ba0397117eb1590e18461ace89ab18141690658a2a537d5d-dd46a31f3cab67b316e9239b15acf7d5cea60aa9", + wallet2_api_c_exp_sha256: "5f53ea8bbe66a5e5aa6cbc4ca00695900e08589cfd32062e88965a24252d05ba", } diff --git a/impls/monero.ts/checksum_zano.ts b/impls/monero.ts/checksum_zano.ts new file mode 100644 index 0000000..2af89bd --- /dev/null +++ b/impls/monero.ts/checksum_zano.ts @@ -0,0 +1,5 @@ +export const zanoChecksum = { + wallet2_api_c_h_sha256: "8acaa95513b85a984c08e05cc3f2ac7530bb8f32946eeeb45357bd846aef33dd", + wallet2_api_c_cpp_sha256: "4efacd3812d53dd268b6869cc0a9560e7320574d96e09136cf067f796edfeba6-2817090c8ac7639d6f697d00fc8bcba2b3681d90", + wallet2_api_c_exp_sha256: "66f3ff655bbfd11ad28c318ab707090b5a93276f436b06f7b1c0f329dba3c9c2", +} diff --git a/impls/monero.ts/mod.ts b/impls/monero.ts/mod.ts index 1eca773..5b9af6c 100644 --- a/impls/monero.ts/mod.ts +++ b/impls/monero.ts/mod.ts @@ -1,6 +1,11 @@ export * from "./src/bindings.ts"; +export * from "./src/coins.ts"; +export * from "./src/coins_info.ts"; export * from "./src/pending_transaction.ts"; +export * from "./src/symbols.ts"; export * from "./src/transaction_history.ts"; export * from "./src/transaction_info.ts"; +export * from "./src/unsigned_transaction.ts"; +export * from "./src/utils.ts"; export * from "./src/wallet.ts"; export * from "./src/wallet_manager.ts"; diff --git a/impls/monero.ts/src/bindings.ts b/impls/monero.ts/src/bindings.ts index 93ce8f9..dc63c03 100644 --- a/impls/monero.ts/src/bindings.ts +++ b/impls/monero.ts/src/bindings.ts @@ -1,8 +1,21 @@ -import { type Dylib, moneroSymbols, type MoneroTsDylib, wowneroSymbols, type WowneroTsDylib } from "./symbols.ts"; +import { type MoneroSymbols, moneroSymbols, type SymbolName, type WowneroSymbols, wowneroSymbols } from "./symbols.ts"; + +export type MoneroDylib = Deno.DynamicLibrary<MoneroSymbols>; +export type WowneroDylib = Deno.DynamicLibrary<WowneroSymbols>; +export type Dylib = MoneroDylib | WowneroDylib; export let dylib: Dylib; -export function loadMoneroDylib(newDylib?: MoneroTsDylib) { +let dylibPrefix = "MONERO"; +export const fns = new Proxy({} as { [K in SymbolName]: MoneroDylib["symbols"][`MONERO_${K}`] }, { + get(_, symbolName: SymbolName) { + return dylib.symbols[`${dylibPrefix}_${symbolName}` as keyof Dylib["symbols"]]; + }, +}); + +export function loadMoneroDylib(newDylib?: MoneroDylib) { + dylibPrefix = "MONERO"; + if (newDylib) { dylib = newDylib; return; @@ -27,7 +40,9 @@ export function loadMoneroDylib(newDylib?: MoneroTsDylib) { dylib = Deno.dlopen(libPath, moneroSymbols); } -export function loadWowneroDylib(newDylib?: WowneroTsDylib) { +export function loadWowneroDylib(newDylib?: WowneroDylib) { + dylibPrefix = "WOWNERO"; + if (newDylib) { dylib = newDylib; return; diff --git a/impls/monero.ts/src/coins.ts b/impls/monero.ts/src/coins.ts new file mode 100644 index 0000000..45a222f --- /dev/null +++ b/impls/monero.ts/src/coins.ts @@ -0,0 +1,53 @@ +import { CoinsInfo, type CoinsInfoPtr } from "./coins_info.ts"; +import { fns } from "./bindings.ts"; + +export type CoinsPtr = Deno.PointerObject<"coins">; + +export class Coins { + #ptr: CoinsPtr; + + #coins: CoinsInfo[] = []; + + constructor(ptr: CoinsPtr) { + this.#ptr = ptr; + } + + async count(): Promise<number> { + return await fns.Coins_count(this.#ptr); + } + + async coin(index: number): Promise<CoinsInfo | null> { + if (this.#coins[index]) { + return this.#coins[index]; + } + + const coinPtr = await fns.Coins_coin(this.#ptr, index); + if (!coinPtr) return null; + + return CoinsInfo.new(coinPtr as CoinsInfoPtr); + } + + async setFrozen(index: number) { + return await fns.Coins_setFrozen(this.#ptr, index); + } + + async thaw(index: number) { + return await fns.Coins_thaw(this.#ptr, index); + } + + async getAllSize(): Promise<number> { + return await fns.Coins_getAll_size(this.#ptr); + } + + async getAllByIndex(index: number): Promise<unknown> { + return await fns.Coins_getAll_byIndex(this.#ptr, index); + } + + async refresh(): Promise<void> { + await fns.Coins_refresh(this.#ptr); + + for (const coin of this.#coins) { + coin.refresh(); + } + } +} diff --git a/impls/monero.ts/src/coins_info.ts b/impls/monero.ts/src/coins_info.ts new file mode 100644 index 0000000..7ea18aa --- /dev/null +++ b/impls/monero.ts/src/coins_info.ts @@ -0,0 +1,85 @@ +import { fns } from "./bindings.ts"; +import { readCString } from "./utils.ts"; + +export type CoinsInfoPtr = Deno.PointerObject<"coinsInfo">; + +export class CoinsInfo { + #ptr: CoinsInfoPtr; + + #hash!: string | null; + #keyImage!: string | null; + #blockHeight!: bigint; + #amount!: bigint; + #spent!: boolean; + #spentHeight!: bigint; + #frozen!: boolean; + #unlocked!: boolean; + + constructor(ptr: CoinsInfoPtr) { + this.#ptr = ptr; + } + + getPointer(): CoinsInfoPtr { + return this.#ptr; + } + + static async new(ptr: CoinsInfoPtr): Promise<CoinsInfo> { + const instance = new CoinsInfo(ptr); + await instance.refresh(); + return instance; + } + + async refresh() { + const [hash, keyImage, blockHeight, amount, spent, spentHeight, frozen, unlocked] = await Promise.all([ + fns.CoinsInfo_hash(this.#ptr).then(readCString), + fns.CoinsInfo_keyImage(this.#ptr).then(readCString), + fns.CoinsInfo_blockHeight(this.#ptr), + fns.CoinsInfo_amount(this.#ptr), + fns.CoinsInfo_spent(this.#ptr), + fns.CoinsInfo_spentHeight(this.#ptr), + fns.CoinsInfo_frozen(this.#ptr), + fns.CoinsInfo_unlocked(this.#ptr), + ]); + + this.#hash = hash; + this.#keyImage = keyImage; + this.#blockHeight = blockHeight; + this.#amount = amount; + this.#spent = spent; + this.#spentHeight = spentHeight; + this.#frozen = frozen; + this.#unlocked = unlocked; + } + + get hash(): string | null { + return this.#hash; + } + + get keyImage(): string | null { + return this.#keyImage; + } + + get blockHeight(): bigint { + return this.#blockHeight; + } + + get amount(): bigint { + return this.#amount; + } + + get spent(): boolean { + return this.#spent; + } + + get spentHeight(): bigint { + return this.#spentHeight; + } + + get frozen(): boolean { + return this.#frozen; + } + + get unlocked(): boolean { + return this.#unlocked; + } +} diff --git a/impls/monero.ts/src/pending_transaction.ts b/impls/monero.ts/src/pending_transaction.ts index 169332f..d80b738 100644 --- a/impls/monero.ts/src/pending_transaction.ts +++ b/impls/monero.ts/src/pending_transaction.ts @@ -1,87 +1,84 @@ -import { CString, getSymbol, readCString, type Sanitizer } from "./utils.ts"; +import { fns } from "./bindings.ts"; +import { C_SEPARATOR, CString, maybeMultipleStrings, readCString } from "./utils.ts"; -export type PendingTransactionPtr = Deno.PointerObject<"transactionInfo">; +export type PendingTransactionPtr = Deno.PointerObject<"pendingTransaction">; -export class PendingTransaction { - #pendingTxPtr: PendingTransactionPtr; - sanitizer?: Sanitizer; +export class PendingTransaction<MultDest extends boolean = false> { + #ptr: PendingTransactionPtr; - constructor(pendingTxPtr: PendingTransactionPtr, sanitizer?: Sanitizer) { - this.sanitizer = sanitizer; - this.#pendingTxPtr = pendingTxPtr; - } + #amount!: bigint; + #dust!: bigint; + #fee!: bigint; + #txid!: string | string[] | null; + #txCount!: bigint; - async status(): Promise<number> { - return await getSymbol("PendingTransaction_status")(this.#pendingTxPtr); + constructor(ptr: PendingTransactionPtr) { + this.#ptr = ptr; } - async errorString(): Promise<string | null> { - if (!await this.status()) return null; + static async new(ptr: PendingTransactionPtr): Promise<PendingTransaction> { + const instance = new PendingTransaction(ptr); - const error = await getSymbol("PendingTransaction_errorString")(this.#pendingTxPtr); - if (!error) return null; + const [amount, dust, fee, txCount, txid] = await Promise.all([ + fns.PendingTransaction_amount(ptr), + fns.PendingTransaction_dust(ptr), + fns.PendingTransaction_fee(ptr), + fns.PendingTransaction_txCount(ptr), + fns.PendingTransaction_txid(ptr, C_SEPARATOR), + ]); - return await readCString(error) || null; - } + instance.#amount = amount; + instance.#dust = dust; + instance.#fee = fee; + instance.#txCount = txCount; + instance.#txid = maybeMultipleStrings(await readCString(txid)); - async throwIfError(sanitize = true): Promise<void> { - const maybeError = await this.errorString(); - if (maybeError) { - if (sanitize) this.sanitizer?.(); - throw new Error(maybeError); - } + return instance; } - async commit(fileName: string, overwrite: boolean, sanitize = true): Promise<boolean> { - const bool = await getSymbol("PendingTransaction_commit")( - this.#pendingTxPtr, - CString(fileName), - overwrite, - ); - await this.throwIfError(sanitize); - return bool; + get amount(): bigint { + return this.#amount; } - async commitUR(maxFragmentLength: number): Promise<string | null> { - const commitUR = getSymbol("PendingTransaction_commitUR"); - - if (!commitUR) { - return null; - } + get dust(): bigint { + return this.#dust; + } - const result = await commitUR( - this.#pendingTxPtr, - maxFragmentLength, - ); + get fee(): bigint { + return this.#fee; + } - if (!result) return null; - await this.throwIfError(); - return await readCString(result) || null; + get txCount(): bigint { + return this.#txCount; } - async amount(): Promise<bigint> { - return await getSymbol("PendingTransaction_amount")(this.#pendingTxPtr); + async commit(fileName: string, overwrite: boolean): Promise<boolean> { + return await fns.PendingTransaction_commit(this.#ptr, CString(fileName), overwrite); } - async dust(): Promise<bigint> { - return await getSymbol("PendingTransaction_dust")(this.#pendingTxPtr); + async commitUR(maxFragmentLength: number): Promise<string | null> { + const commitUR = fns.PendingTransaction_commitUR; + if (!commitUR) return null; + + return await readCString( + await commitUR(this.#ptr, maxFragmentLength), + ); } - async fee(): Promise<bigint> { - return await getSymbol("PendingTransaction_fee")(this.#pendingTxPtr); + async status(): Promise<number> { + return await fns.PendingTransaction_status(this.#ptr); } - async txid(separator: string, sanitize = true): Promise<string | null> { - const result = await getSymbol("PendingTransaction_txid")( - this.#pendingTxPtr, - CString(separator), - ); - if (!result) return null; - await this.throwIfError(sanitize); - return await readCString(result) || null; + async errorString(): Promise<string | null> { + if (!await this.status()) return null; + const error = await fns.PendingTransaction_errorString(this.#ptr); + return await readCString(error); } - async txCount(): Promise<bigint> { - return await getSymbol("PendingTransaction_txCount")(this.#pendingTxPtr); + async throwIfError(): Promise<void> { + const maybeError = await this.errorString(); + if (maybeError) { + throw new Error(maybeError); + } } } diff --git a/impls/monero.ts/src/symbols.ts b/impls/monero.ts/src/symbols.ts index 38707b8..91d95b2 100644 --- a/impls/monero.ts/src/symbols.ts +++ b/impls/monero.ts/src/symbols.ts @@ -1,553 +1,2444 @@ export const moneroSymbols = { - "MONERO_WalletManagerFactory_getWalletManager": { + MONERO_PendingTransaction_status: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_errorString: { nonblocking: true, - parameters: [], - // void* result: "pointer", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], }, - - //#region WalletManager - "MONERO_WalletManager_createWallet": { + MONERO_PendingTransaction_commit: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "bool"] as [ + pendingTx_ptr: "pointer", + filename: "pointer", + overwrite: "bool", + ], + }, + MONERO_PendingTransaction_commitUR: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + pendingTx_ptr: "pointer", + max_fragment_length: "i32", + ], + }, + MONERO_PendingTransaction_amount: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_dust: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_fee: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_txid: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + pendingTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_PendingTransaction_txCount: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_subaddrAccount: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + pendingTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_PendingTransaction_subaddrIndices: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + pendingTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_PendingTransaction_multisigSignData: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_signMultisigTx: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + pendingTx_ptr: "pointer", + ], + }, + MONERO_PendingTransaction_signersKeys: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + pendingTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_PendingTransaction_hex: { nonblocking: true, - // void* wm_ptr, const char* path, const char* password, const char* language, int networkType - parameters: ["pointer", "pointer", "pointer", "pointer", "i32"], - // void* result: "pointer", + parameters: ["pointer", "pointer"] as [ + pendingTx_ptr: "pointer", + separator: "pointer", + ], }, - "MONERO_WalletManager_openWallet": { + MONERO_PendingTransaction_txKey: { + optional: true, nonblocking: true, - // void* wm_ptr, const char* path, const char* password, int networkType - "parameters": ["pointer", "pointer", "pointer", "i32"], - // void* result: "pointer", + parameters: ["pointer", "pointer"] as [ + pendingTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_UnsignedTransaction_status: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + unsignedTx_ptr: "pointer", + ], }, - "MONERO_WalletManager_recoveryWallet": { + MONERO_UnsignedTransaction_errorString: { nonblocking: true, - // void* wm_ptr, const char* path, const char* password, const char* mnemonic, - // int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset - parameters: ["pointer", "pointer", "pointer", "pointer", "i32", "u64", "u64", "pointer"], - // void* result: "pointer", + parameters: ["pointer"] as [ + unsignedTx_ptr: "pointer", + ], }, - "MONERO_WalletManager_blockchainHeight": { + MONERO_UnsignedTransaction_amount: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + unsignedTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_UnsignedTransaction_fee: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + unsignedTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_UnsignedTransaction_mixin: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + unsignedTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_UnsignedTransaction_confirmationMessage: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + unsignedTx_ptr: "pointer", + ], + }, + MONERO_UnsignedTransaction_paymentId: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + unsignedTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_UnsignedTransaction_recipientAddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + unsignedTx_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_UnsignedTransaction_minMixinCount: { nonblocking: true, - // void* wm_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + unsignedTx_ptr: "pointer", + ], }, - "MONERO_WalletManager_blockchainTargetHeight": { + MONERO_UnsignedTransaction_txCount: { nonblocking: true, - // void* wm_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + unsignedTx_ptr: "pointer", + ], }, - "MONERO_WalletManager_setDaemonAddress": { + MONERO_UnsignedTransaction_sign: { nonblocking: true, - // void* wm_ptr, const char* address - parameters: ["pointer", "pointer"], - // void - result: "void", + result: "bool", + parameters: ["pointer", "pointer"] as [ + unsignedTx_ptr: "pointer", + signedFileName: "pointer", + ], }, - //#endregion - - //#region Wallet - "MONERO_Wallet_init": { + MONERO_UnsignedTransaction_signUR: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + unsignedTx_ptr: "pointer", + max_fragment_length: "i32", + ], + }, + MONERO_TransactionInfo_direction: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_isPending: { nonblocking: true, - // void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, - // const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, - // const char* proxy_address - parameters: ["pointer", "pointer", "u64", "pointer", "pointer", "bool", "bool", "pointer"], - // bool result: "bool", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_init3": { + MONERO_TransactionInfo_isFailed: { nonblocking: true, - // void* wallet_ptr, const char* argv0, const char* default_log_base_name, - // const char* log_path, bool console - parameters: ["pointer", "pointer", "pointer", "pointer", "bool"], - // void - result: "void", + result: "bool", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_isCoinbase: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_amount: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_fee: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_blockHeight: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_description: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_subaddrIndex: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + txInfo_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_TransactionInfo_subaddrAccount: { + nonblocking: true, + result: "u32", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_label: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_confirmations: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_unlockTime: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_hash: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_timestamp: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_paymentId: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_transfers_count: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + txInfo_ptr: "pointer", + ], + }, + MONERO_TransactionInfo_transfers_amount: { + nonblocking: true, + result: "u64", + parameters: ["pointer", "i32"] as [ + txInfo_ptr: "pointer", + index: "i32", + ], + }, + MONERO_TransactionInfo_transfers_address: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + txInfo_ptr: "pointer", + index: "i32", + ], + }, + MONERO_TransactionHistory_count: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + txHistory_ptr: "pointer", + ], + }, + MONERO_TransactionHistory_transaction: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + txHistory_ptr: "pointer", + index: "i32", + ], + }, + MONERO_TransactionHistory_transactionById: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + txHistory_ptr: "pointer", + id: "pointer", + ], }, - "MONERO_Wallet_setTrustedDaemon": { + MONERO_TransactionHistory_refresh: { nonblocking: true, - // void* wallet_ptr, bool arg - parameters: ["pointer", "bool"], - // void result: "void", + parameters: ["pointer"] as [ + txHistory_ptr: "pointer", + ], }, - "MONERO_Wallet_startRefresh": { + MONERO_TransactionHistory_setTxNote: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // void result: "void", + parameters: ["pointer", "pointer", "pointer"] as [ + txHistory_ptr: "pointer", + txid: "pointer", + note: "pointer", + ], + }, + MONERO_AddressBookRow_extra: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + addressBookRow_ptr: "pointer", + ], + }, + MONERO_AddressBookRow_getAddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + addressBookRow_ptr: "pointer", + ], + }, + MONERO_AddressBookRow_getDescription: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + addressBookRow_ptr: "pointer", + ], }, - "MONERO_Wallet_refreshAsync": { + MONERO_AddressBookRow_getPaymentId: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + addressBookRow_ptr: "pointer", + ], + }, + MONERO_AddressBookRow_getRowId: { + nonblocking: true, + result: "usize", + parameters: ["pointer"] as [ + addressBookRow_ptr: "pointer", + ], + }, + MONERO_AddressBook_getAll_size: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + addressBook_ptr: "pointer", + ], + }, + MONERO_AddressBook_getAll_byIndex: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + addressBook_ptr: "pointer", + index: "i32", + ], + }, + MONERO_AddressBook_addRow: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "pointer", "pointer"] as [ + addressBook_ptr: "pointer", + dst_addr: "pointer", + payment_id: "pointer", + description: "pointer", + ], + }, + MONERO_AddressBook_deleteRow: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "usize"] as [ + addressBook_ptr: "pointer", + rowId: "usize", + ], + }, + MONERO_AddressBook_setDescription: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "usize", "pointer"] as [ + addressBook_ptr: "pointer", + rowId: "usize", + description: "pointer", + ], + }, + MONERO_AddressBook_refresh: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // void result: "void", + parameters: ["pointer"] as [ + addressBook_ptr: "pointer", + ], + }, + MONERO_AddressBook_errorString: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + addressBook_ptr: "pointer", + ], }, - "MONERO_Wallet_blockChainHeight": { + MONERO_AddressBook_errorCode: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + addressBook_ptr: "pointer", + ], + }, + MONERO_AddressBook_lookupPaymentID: { + nonblocking: true, + result: "i32", + parameters: ["pointer", "pointer"] as [ + addressBook_ptr: "pointer", + payment_id: "pointer", + ], + }, + MONERO_CoinsInfo_blockHeight: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_hash: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_internalOutputIndex: { + nonblocking: true, + result: "usize", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_daemonBlockChainHeight": { + MONERO_CoinsInfo_globalOutputIndex: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_synchronized": { + MONERO_CoinsInfo_spent: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // bool result: "bool", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_store": { + MONERO_CoinsInfo_frozen: { nonblocking: true, - // void* wallet_ptr, const char* path - parameters: ["pointer", "pointer"], - // bool result: "bool", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_address": { + MONERO_CoinsInfo_spentHeight: { nonblocking: true, - // void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex - parameters: ["pointer", "u64", "u64"], - // char* - result: "pointer", + result: "u64", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_balance": { + MONERO_CoinsInfo_amount: { nonblocking: true, - // void* wallet_ptr, uint32_t accountIndex - parameters: ["pointer", "u32"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_rct: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_keyImageKnown: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_pkIndex: { + nonblocking: true, + result: "usize", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_subaddrIndex: { + nonblocking: true, + result: "u32", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_subaddrAccount: { + nonblocking: true, + result: "u32", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_address: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_addressLabel: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_keyImage: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], }, - "MONERO_Wallet_unlockedBalance": { + MONERO_CoinsInfo_unlockTime: { nonblocking: true, - // void* wallet_ptr, uint32_t accountIndex - parameters: ["pointer", "u32"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_unlocked: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_pubKey: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_coinbase: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_CoinsInfo_description: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + coinsInfo_ptr: "pointer", + ], + }, + MONERO_Coins_count: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + coins_ptr: "pointer", + ], + }, + MONERO_Coins_coin: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + coins_ptr: "pointer", + index: "i32", + ], + }, + MONERO_Coins_getAll_size: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + coins_ptr: "pointer", + ], + }, + MONERO_Coins_getAll_byIndex: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + coins_ptr: "pointer", + index: "i32", + ], + }, + MONERO_Coins_refresh: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + coins_ptr: "pointer", + ], + }, + MONERO_Coins_setFrozenByPublicKey: { + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer"] as [ + coins_ptr: "pointer", + public_key: "pointer", + ], + }, + MONERO_Coins_setFrozen: { + nonblocking: true, + result: "void", + parameters: ["pointer", "i32"] as [ + coins_ptr: "pointer", + index: "i32", + ], }, - "MONERO_Wallet_addSubaddressAccount": { + MONERO_Coins_thaw: { nonblocking: true, - // void* wallet_ptr, const char* label - parameters: ["pointer", "pointer"], - // void result: "void", + parameters: ["pointer", "i32"] as [ + coins_ptr: "pointer", + index: "i32", + ], }, - "MONERO_Wallet_numSubaddressAccounts": { + MONERO_Coins_thawByPublicKey: { + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer"] as [ + coins_ptr: "pointer", + public_key: "pointer", + ], + }, + MONERO_Coins_isTransferUnlocked: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "u64", "u64"] as [ + coins_ptr: "pointer", + unlockTime: "u64", + blockHeight: "u64", + ], + }, + MONERO_Coins_setDescription: { + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer", "pointer"] as [ + coins_ptr: "pointer", + public_key: "pointer", + description: "pointer", + ], + }, + MONERO_SubaddressRow_extra: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressRow_ptr: "pointer", + ], + }, + MONERO_SubaddressRow_getAddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressRow_ptr: "pointer", + ], + }, + MONERO_SubaddressRow_getLabel: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressRow_ptr: "pointer", + ], + }, + MONERO_SubaddressRow_getRowId: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // size_t result: "usize", + parameters: ["pointer"] as [ + subaddressRow_ptr: "pointer", + ], + }, + MONERO_Subaddress_getAll_size: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + subaddress_ptr: "pointer", + ], + }, + MONERO_Subaddress_getAll_byIndex: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "i32"] as [ + subaddress_ptr: "pointer", + index: "i32", + ], }, - "MONERO_Wallet_addSubaddress": { + MONERO_Subaddress_addRow: { nonblocking: true, - // void* wallet_ptr, uint32_t accountIndex, const char* label - parameters: ["pointer", "u32", "pointer"], - // void result: "void", + parameters: ["pointer", "u32", "pointer"] as [ + subaddress_ptr: "pointer", + accountIndex: "u32", + label: "pointer", + ], }, - "MONERO_Wallet_numSubaddresses": { + MONERO_Subaddress_setLabel: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32", "u32", "pointer"] as [ + subaddress_ptr: "pointer", + accountIndex: "u32", + addressIndex: "u32", + label: "pointer", + ], + }, + MONERO_Subaddress_refresh: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32"] as [ + subaddress_ptr: "pointer", + accountIndex: "u32", + ], + }, + MONERO_SubaddressAccountRow_extra: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressAccountRow_ptr: "pointer", + ], + }, + MONERO_SubaddressAccountRow_getAddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressAccountRow_ptr: "pointer", + ], + }, + MONERO_SubaddressAccountRow_getLabel: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressAccountRow_ptr: "pointer", + ], + }, + MONERO_SubaddressAccountRow_getBalance: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressAccountRow_ptr: "pointer", + ], + }, + MONERO_SubaddressAccountRow_getUnlockedBalance: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + subaddressAccountRow_ptr: "pointer", + ], + }, + MONERO_SubaddressAccountRow_getRowId: { nonblocking: true, - // void* wallet_ptr, uint32_t accountIndex - parameters: ["pointer", "u32"], - // size_t result: "usize", + parameters: ["pointer"] as [ + subaddressAccountRow_ptr: "pointer", + ], + }, + MONERO_SubaddressAccount_getAll_size: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + subaddressAccount_ptr: "pointer", + ], }, - "MONERO_Wallet_getSubaddressLabel": { + MONERO_SubaddressAccount_getAll_byIndex: { nonblocking: true, - // void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex - parameters: ["pointer", "u32", "u32"], - // const char* result: "pointer", + parameters: ["pointer", "i32"] as [ + subaddressAccount_ptr: "pointer", + index: "i32", + ], }, - "MONERO_Wallet_setSubaddressLabel": { + MONERO_SubaddressAccount_addRow: { nonblocking: true, - // void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label - parameters: ["pointer", "u32", "u32", "pointer"], - // void result: "void", + parameters: ["pointer", "pointer"] as [ + subaddressAccount_ptr: "pointer", + label: "pointer", + ], }, - "MONERO_Wallet_status": { + MONERO_SubaddressAccount_setLabel: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32", "pointer"] as [ + subaddressAccount_ptr: "pointer", + accountIndex: "u32", + label: "pointer", + ], + }, + MONERO_SubaddressAccount_refresh: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + subaddressAccount_ptr: "pointer", + ], + }, + MONERO_MultisigState_isMultisig: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + multisigState_ptr: "pointer", + ], + }, + MONERO_MultisigState_isReady: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + multisigState_ptr: "pointer", + ], + }, + MONERO_MultisigState_threshold: { + nonblocking: true, + result: "u32", + parameters: ["pointer"] as [ + multisigState_ptr: "pointer", + ], + }, + MONERO_MultisigState_total: { + nonblocking: true, + result: "u32", + parameters: ["pointer"] as [ + multisigState_ptr: "pointer", + ], + }, + MONERO_DeviceProgress_progress: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + deviceProgress_ptr: "pointer", + ], + }, + MONERO_DeviceProgress_indeterminate: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + deviceProgress_ptr: "pointer", + ], + }, + MONERO_Wallet_seed: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + seed_offset: "pointer", + ], + }, + MONERO_Wallet_getSeedLanguage: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setSeedLanguage: { + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + arg: "pointer", + ], + }, + MONERO_Wallet_status: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // int result: "i32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_Wallet_errorString": { + MONERO_Wallet_errorString: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // char* result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setPassword: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + password: "pointer", + ], }, - "MONERO_Wallet_history": { + MONERO_Wallet_getPassword: { nonblocking: true, - // void* wallet_ptr - parameters: ["pointer"], - // void* result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_Wallet_createTransaction": { + MONERO_Wallet_setDevicePin: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + pin: "pointer", + ], + }, + MONERO_Wallet_setDevicePassphrase: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + passphrase: "pointer", + ], + }, + MONERO_Wallet_address: { nonblocking: true, - // void* wallet_ptr, const char* dst_addr, const char* payment_id - // uint64_t amount, uint32_t mixin_count, int pendingTransactionPriority, - // uint32_t subaddr_account, const char* preferredInputs, const char* separator - parameters: ["pointer", "pointer", "pointer", "u64", "u32", "i32", "u32", "pointer", "pointer"], - // void* result: "pointer", + parameters: ["pointer", "u64", "u64"] as [ + wallet_ptr: "pointer", + accountIndex: "u64", + addressIndex: "u64", + ], }, - "MONERO_Wallet_amountFromString": { + MONERO_Wallet_path: { nonblocking: true, - // const char* amount - parameters: ["pointer"], - // uint64_t - result: "u64", + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - //#endregion - - //#region TransactionHistory - "MONERO_TransactionHistory_count": { + MONERO_Wallet_nettype: { nonblocking: true, - // void* txHistory_ptr - parameters: ["pointer"], - // int result: "i32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_integratedAddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + payment_id: "pointer", + ], }, - "MONERO_TransactionHistory_transaction": { + MONERO_Wallet_secretViewKey: { nonblocking: true, - // void* txHistory_ptr, int index - parameters: ["pointer", "i32"], - // void* result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionHistory_transactionById": { + MONERO_Wallet_publicViewKey: { nonblocking: true, - // void* txHistory_ptr, const char* id - parameters: ["pointer", "pointer"], - // void* result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionHistory_refresh": { + MONERO_Wallet_secretSpendKey: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_publicSpendKey: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_publicMultisigSignerKey: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_stop: { nonblocking: true, - // void* txHistory_ptr - parameters: ["pointer"], - // void result: "void", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_store: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + path: "pointer", + ], }, - "MONERO_TransactionHistory_setTxNote": { + MONERO_Wallet_filename: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_keysFilename: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_init: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "u64", "pointer", "pointer", "bool", "bool", "pointer"] as [ + wallet_ptr: "pointer", + daemon_address: "pointer", + upper_transaction_size_limit: "u64", + daemon_username: "pointer", + daemon_password: "pointer", + use_ssl: "bool", + lightWallet: "bool", + proxy_address: "pointer", + ], + }, + MONERO_Wallet_createWatchOnly: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + path: "pointer", + password: "pointer", + language: "pointer", + ], + }, + MONERO_Wallet_setRefreshFromBlockHeight: { nonblocking: true, - // void* txHistory_ptr, const char* txid, const char* note - parameters: ["pointer", "pointer", "pointer"], - // void result: "void", + parameters: ["pointer", "u64"] as [ + wallet_ptr: "pointer", + refresh_from_block_height: "u64", + ], }, - //#endregion - - //#region TransactionInfo - "MONERO_TransactionInfo_direction": { + MONERO_Wallet_getRefreshFromBlockHeight: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setRecoveringFromSeed: { + nonblocking: true, + result: "void", + parameters: ["pointer", "bool"] as [ + wallet_ptr: "pointer", + recoveringFromSeed: "bool", + ], + }, + MONERO_Wallet_setRecoveringFromDevice: { + nonblocking: true, + result: "void", + parameters: ["pointer", "bool"] as [ + wallet_ptr: "pointer", + recoveringFromDevice: "bool", + ], + }, + MONERO_Wallet_setSubaddressLookahead: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32", "u32"] as [ + wallet_ptr: "pointer", + major: "u32", + minor: "u32", + ], + }, + MONERO_Wallet_connectToDaemon: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_connected: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // int result: "i32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setTrustedDaemon: { + nonblocking: true, + result: "void", + parameters: ["pointer", "bool"] as [ + wallet_ptr: "pointer", + arg: "bool", + ], }, - "MONERO_TransactionInfo_isPending": { + MONERO_Wallet_trustedDaemon: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // bool result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setProxy: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + address: "pointer", + ], + }, + MONERO_Wallet_balance: { + nonblocking: true, + result: "u64", + parameters: ["pointer", "u32"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + ], + }, + MONERO_Wallet_unlockedBalance: { + nonblocking: true, + result: "u64", + parameters: ["pointer", "u32"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + ], + }, + MONERO_Wallet_viewOnlyBalance: { + nonblocking: true, + result: "u64", + parameters: ["pointer", "u32"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + ], }, - "MONERO_TransactionInfo_isFailed": { + MONERO_Wallet_watchOnly: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // bool result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_isCoinbase": { + MONERO_Wallet_isDeterministic: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // bool result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_amount": { + MONERO_Wallet_blockChainHeight: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_fee": { + MONERO_Wallet_approximateBlockChainHeight: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_blockHeight": { + MONERO_Wallet_estimateBlockChainHeight: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_description": { + MONERO_Wallet_daemonBlockChainHeight: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // const char* - result: "pointer", + result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_subaddrIndex": { + MONERO_Wallet_daemonBlockChainTargetHeight: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // const char* - result: "pointer", + result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_subaddrAccount": { + MONERO_Wallet_synchronized: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint32_t - result: "u32", + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_TransactionInfo_label": { + MONERO_Wallet_displayAmount: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // const char* result: "pointer", + parameters: ["u64"] as [ + amount: "u64", + ], }, - "MONERO_TransactionInfo_confirmations": { + MONERO_Wallet_amountFromString: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + amount: "pointer", + ], }, - "MONERO_TransactionInfo_unlockTime": { + MONERO_Wallet_amountFromDouble: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["f64"] as [ + amount: "f64", + ], }, - "MONERO_TransactionInfo_hash": { + MONERO_Wallet_genPaymentId: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // const char* result: "pointer", + parameters: [], }, - "MONERO_TransactionInfo_timestamp": { + MONERO_Wallet_paymentIdValid: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // uint64_t - result: "u64", + result: "bool", + parameters: ["pointer"] as [ + paiment_id: "pointer", + ], + }, + MONERO_Wallet_addressValid: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "i32"] as [ + str: "pointer", + nettype: "i32", + ], + }, + MONERO_Wallet_keyValid: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "bool", "i32"] as [ + secret_key_string: "pointer", + address_string: "pointer", + isViewKey: "bool", + nettype: "i32", + ], }, - "MONERO_TransactionInfo_paymentId": { + MONERO_Wallet_keyValid_error: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // const char* result: "pointer", + parameters: ["pointer", "pointer", "bool", "i32"] as [ + secret_key_string: "pointer", + address_string: "pointer", + isViewKey: "bool", + nettype: "i32", + ], }, - "MONERO_TransactionInfo_transfers_count": { + MONERO_Wallet_paymentIdFromAddress: { nonblocking: true, - // void* txInfo_ptr - parameters: ["pointer"], - // int - result: "i32", + result: "pointer", + parameters: ["pointer", "i32"] as [ + strarg: "pointer", + nettype: "i32", + ], }, - "MONERO_TransactionInfo_transfers_amount": { + MONERO_Wallet_maximumAllowedAmount: { nonblocking: true, - // void* txInfo_ptr, int index - parameters: ["pointer", "i32"], - // uint64_t result: "u64", + parameters: [], + }, + MONERO_Wallet_init3: { + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer", "pointer", "pointer", "bool"] as [ + wallet_ptr: "pointer", + argv0: "pointer", + default_log_base_name: "pointer", + log_path: "pointer", + console: "bool", + ], }, - "MONERO_TransactionInfo_transfers_address": { + MONERO_Wallet_getPolyseed: { nonblocking: true, - // void* txInfo_ptr, int index - parameters: ["pointer", "i32"], - // const char* result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + passphrase: "pointer", + ], }, - //#endregion - - //#region PendingTransaction - "MONERO_PendingTransaction_status": { + MONERO_Wallet_createPolyseed: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + language: "pointer", + ], + }, + MONERO_Wallet_startRefresh: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_pauseRefresh: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_refresh: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_refreshAsync: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_rescanBlockchain: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_rescanBlockchainAsync: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setAutoRefreshInterval: { + nonblocking: true, + result: "void", + parameters: ["pointer", "i32"] as [ + wallet_ptr: "pointer", + millis: "i32", + ], + }, + MONERO_Wallet_autoRefreshInterval: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // int result: "i32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_addSubaddressAccount: { + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + label: "pointer", + ], + }, + MONERO_Wallet_numSubaddressAccounts: { + nonblocking: true, + result: "usize", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_numSubaddresses: { + nonblocking: true, + result: "usize", + parameters: ["pointer", "u32"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + ], + }, + MONERO_Wallet_addSubaddress: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32", "pointer"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + label: "pointer", + ], + }, + MONERO_Wallet_getSubaddressLabel: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "u32", "u32"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + addressIndex: "u32", + ], + }, + MONERO_Wallet_setSubaddressLabel: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32", "u32", "pointer"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + addressIndex: "u32", + label: "pointer", + ], + }, + MONERO_Wallet_multisig: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getMultisigInfo: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_makeMultisig: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "u32"] as [ + wallet_ptr: "pointer", + info: "pointer", + info_separator: "pointer", + threshold: "u32", + ], + }, + MONERO_Wallet_exchangeMultisigKeys: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "bool"] as [ + wallet_ptr: "pointer", + info: "pointer", + info_separator: "pointer", + force_update_use_with_caution: "bool", + ], + }, + MONERO_Wallet_exportMultisigImages: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + separator: "pointer", + ], + }, + MONERO_Wallet_importMultisigImages: { + optional: true, + nonblocking: true, + result: "usize", + parameters: ["pointer", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + info: "pointer", + info_separator: "pointer", + ], + }, + MONERO_Wallet_hasMultisigPartialKeyImages: { + optional: true, + nonblocking: true, + result: "usize", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_PendingTransaction_errorString": { + MONERO_Wallet_restoreMultisigTransaction: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + signData: "pointer", + ], + }, + MONERO_Wallet_createTransactionMultDest: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: [ + "pointer", + "pointer", + "pointer", + "pointer", + "bool", + "pointer", + "pointer", + "u32", + "i32", + "u32", + "pointer", + "pointer", + ] as [ + wallet_ptr: "pointer", + dst_addr_list: "pointer", + dst_addr_list_separator: "pointer", + payment_id: "pointer", + amount_sweep_all: "bool", + amount_list: "pointer", + amount_list_separator: "pointer", + mixin_count: "u32", + pendingTransactionPriority: "i32", + subaddr_account: "u32", + preferredInputs: "pointer", + preferredInputs_separator: "pointer", + ], + }, + MONERO_Wallet_createTransaction: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "u64", "u32", "i32", "u32", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + dst_addr: "pointer", + payment_id: "pointer", + amount: "u64", + mixin_count: "u32", + pendingTransactionPriority: "i32", + subaddr_account: "u32", + preferredInputs: "pointer", + separator: "pointer", + ], + }, + MONERO_Wallet_loadUnsignedTx: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + fileName: "pointer", + ], + }, + MONERO_Wallet_loadUnsignedTxUR: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + input: "pointer", + ], + }, + MONERO_Wallet_submitTransaction: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + fileName: "pointer", + ], + }, + MONERO_Wallet_submitTransactionUR: { + optional: true, + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + input: "pointer", + ], + }, + MONERO_Wallet_hasUnknownKeyImages: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_exportKeyImages: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "bool"] as [ + wallet_ptr: "pointer", + filename: "pointer", + all: "bool", + ], + }, + MONERO_Wallet_exportKeyImagesUR: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "usize", "bool"] as [ + wallet_ptr: "pointer", + max_fragment_length: "usize", + all: "bool", + ], + }, + MONERO_Wallet_importKeyImages: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + filename: "pointer", + ], + }, + MONERO_Wallet_importKeyImagesUR: { + optional: true, + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + input: "pointer", + ], + }, + MONERO_Wallet_exportOutputs: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "bool"] as [ + wallet_ptr: "pointer", + filename: "pointer", + all: "bool", + ], + }, + MONERO_Wallet_exportOutputsUR: { + optional: true, nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // const char* result: "pointer", + parameters: ["pointer", "usize", "bool"] as [ + wallet_ptr: "pointer", + max_fragment_length: "usize", + all: "bool", + ], }, - "MONERO_PendingTransaction_commit": { + MONERO_Wallet_importOutputs: { nonblocking: true, - // void* pendingTx_ptr, const char* filename, bool overwrite - parameters: ["pointer", "pointer", "bool"], - // bool result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + filename: "pointer", + ], }, - "MONERO_PendingTransaction_commitUR": { + MONERO_Wallet_importOutputsUR: { optional: true, nonblocking: true, - // void* pendingTx_ptr, int max_fragment_length - parameters: ["pointer", "i32"], - // const char* + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + input: "pointer", + ], + }, + MONERO_Wallet_setupBackgroundSync: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "i32", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + background_sync_type: "i32", + wallet_password: "pointer", + background_cache_password: "pointer", + ], + }, + MONERO_Wallet_getBackgroundSyncType: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_startBackgroundSync: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_stopBackgroundSync: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + wallet_password: "pointer", + ], + }, + MONERO_Wallet_isBackgroundSyncing: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_isBackgroundWallet: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_history: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_addressBook: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_coins: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_subaddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_subaddressAccount: { + nonblocking: true, + result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_defaultMixin: { + nonblocking: true, + result: "u32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setDefaultMixin: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u32"] as [ + wallet_ptr: "pointer", + arg: "u32", + ], + }, + MONERO_Wallet_setCacheAttribute: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + key: "pointer", + val: "pointer", + ], + }, + MONERO_Wallet_getCacheAttribute: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + key: "pointer", + ], + }, + MONERO_Wallet_setUserNote: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + txid: "pointer", + note: "pointer", + ], + }, + MONERO_Wallet_getUserNote: { + nonblocking: true, result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + txid: "pointer", + ], }, - "MONERO_PendingTransaction_amount": { + MONERO_Wallet_getTxKey: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer"] as [ + wallet_ptr: "pointer", + txid: "pointer", + ], + }, + MONERO_Wallet_signMessage: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + message: "pointer", + address: "pointer", + ], + }, + MONERO_Wallet_verifySignedMessage: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "pointer", "pointer"] as [ + wallet_ptr: "pointer", + message: "pointer", + address: "pointer", + signature: "pointer", + ], + }, + MONERO_Wallet_rescanSpent: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setOffline: { + nonblocking: true, + result: "void", + parameters: ["pointer", "bool"] as [ + wallet_ptr: "pointer", + offline: "bool", + ], + }, + MONERO_Wallet_isOffline: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_segregatePreForkOutputs: { + nonblocking: true, + result: "void", + parameters: ["pointer", "bool"] as [ + wallet_ptr: "pointer", + segregate: "bool", + ], + }, + MONERO_Wallet_segregationHeight: { + nonblocking: true, + result: "void", + parameters: ["pointer", "u64"] as [ + wallet_ptr: "pointer", + height: "u64", + ], + }, + MONERO_Wallet_keyReuseMitigation2: { + nonblocking: true, + result: "void", + parameters: ["pointer", "bool"] as [ + wallet_ptr: "pointer", + mitigation: "bool", + ], + }, + MONERO_Wallet_lockKeysFile: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_unlockKeysFile: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_isKeysFileLocked: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getDeviceType: { + nonblocking: true, + result: "i32", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_coldKeyImageSync: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer", "u64", "u64"] as [ + wallet_ptr: "pointer", + spent: "u64", + unspent: "u64", + ], + }, + MONERO_Wallet_deviceShowAddress: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "u32", "u32"] as [ + wallet_ptr: "pointer", + accountIndex: "u32", + addressIndex: "u32", + ], }, - "MONERO_PendingTransaction_dust": { + MONERO_Wallet_reconnectDevice: { + optional: true, + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getBytesReceived: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_PendingTransaction_fee": { + MONERO_Wallet_getBytesSent: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // uint64_t result: "u64", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_PendingTransaction_txid": { + MONERO_Wallet_getStateIsConnected: { + optional: true, + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getSendToDevice: { + optional: true, nonblocking: true, - // void* pendingTx_ptr, const char* separator - parameters: ["pointer", "pointer"], - // const char* result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_PendingTransaction_txCount": { + MONERO_Wallet_getSendToDeviceLength: { + optional: true, nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // uint64_t - result: "u64", + result: "usize", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], }, - "MONERO_PendingTransaction_subaddrAccount": { + MONERO_Wallet_getReceivedFromDevice: { + optional: true, nonblocking: true, - // void* pendingTx_ptr, const char* separator - parameters: ["pointer", "pointer"], - // const char* result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getReceivedFromDeviceLength: { + optional: true, + nonblocking: true, + result: "usize", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getWaitsForDeviceSend: { + optional: true, + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_getWaitsForDeviceReceive: { + optional: true, + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_Wallet_setDeviceReceivedData: { + optional: true, + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer", "usize"] as [ + wallet_ptr: "pointer", + data: "pointer", + len: "usize", + ], + }, + MONERO_Wallet_setDeviceSendData: { + optional: true, + nonblocking: true, + result: "void", + parameters: ["pointer", "pointer", "usize"] as [ + wallet_ptr: "pointer", + data: "pointer", + len: "usize", + ], + }, + MONERO_WalletManager_createWallet: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "pointer", "i32"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + language: "pointer", + networkType: "i32", + ], + }, + MONERO_WalletManager_openWallet: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "i32"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + networkType: "i32", + ], + }, + MONERO_WalletManager_recoveryWallet: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "pointer", "i32", "u64", "u64", "pointer"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + mnemonic: "pointer", + networkType: "i32", + restoreHeight: "u64", + kdfRounds: "u64", + seedOffset: "pointer", + ], + }, + MONERO_WalletManager_createWalletFromKeys: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "pointer", "i32", "u64", "pointer", "pointer", "pointer", "u64"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + language: "pointer", + nettype: "i32", + restoreHeight: "u64", + addressString: "pointer", + viewKeyString: "pointer", + spendKeyString: "pointer", + kdf_rounds: "u64", + ], + }, + MONERO_WalletManager_createWalletFromDevice: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "i32", "pointer", "u64", "pointer", "pointer", "pointer", "u64"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + nettype: "i32", + deviceName: "pointer", + restoreHeight: "u64", + subaddressLookahead: "pointer", + viewKeyString: "pointer", + spendKeyString: "pointer", + kdf_rounds: "u64", + ], + }, + MONERO_WalletManager_createDeterministicWalletFromSpendKey: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "pointer", "i32", "u64", "pointer", "u64"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + language: "pointer", + nettype: "i32", + restoreHeight: "u64", + spendKeyString: "pointer", + kdf_rounds: "u64", + ], + }, + MONERO_WalletManager_createWalletFromPolyseed: { + nonblocking: true, + result: "pointer", + parameters: ["pointer", "pointer", "pointer", "i32", "pointer", "pointer", "bool", "u64", "u64"] as [ + wm_ptr: "pointer", + path: "pointer", + password: "pointer", + nettype: "i32", + mnemonic: "pointer", + passphrase: "pointer", + newWallet: "bool", + restore_height: "u64", + kdf_rounds: "u64", + ], + }, + MONERO_WalletManager_closeWallet: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "bool"] as [ + wm_ptr: "pointer", + wallet_ptr: "pointer", + store: "bool", + ], }, - "MONERO_PendingTransaction_subaddrIndices": { + MONERO_WalletManager_walletExists: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wm_ptr: "pointer", + path: "pointer", + ], + }, + MONERO_WalletManager_verifyWalletPassword: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "pointer", "bool", "u64"] as [ + wm_ptr: "pointer", + keys_file_name: "pointer", + password: "pointer", + no_spend_key: "bool", + kdf_rounds: "u64", + ], + }, + MONERO_WalletManager_queryWalletDevice: { + optional: true, + nonblocking: true, + result: "i32", + parameters: ["pointer", "pointer", "pointer", "u64"] as [ + wm_ptr: "pointer", + keys_file_name: "pointer", + password: "pointer", + kdf_rounds: "u64", + ], + }, + MONERO_WalletManager_findWallets: { nonblocking: true, - // void* pendingTx_ptr, const char* separator - parameters: ["pointer", "pointer"], - // const char* result: "pointer", + parameters: ["pointer", "pointer", "pointer"] as [ + wm_ptr: "pointer", + path: "pointer", + separator: "pointer", + ], }, - "MONERO_PendingTransaction_multisigSignData": { + MONERO_WalletManager_errorString: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // const char* result: "pointer", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], }, - "MONERO_PendingTransaction_signMultisigTx": { + MONERO_WalletManager_setDaemonAddress: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // void result: "void", + parameters: ["pointer", "pointer"] as [ + wm_ptr: "pointer", + address: "pointer", + ], + }, + MONERO_WalletManager_setProxy: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wm_ptr: "pointer", + address: "pointer", + ], + }, + MONERO_WalletManager_blockchainHeight: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], + }, + MONERO_WalletManager_blockchainTargetHeight: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], + }, + MONERO_WalletManager_networkDifficulty: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], + }, + MONERO_WalletManager_miningHashRate: { + nonblocking: true, + result: "f64", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], + }, + MONERO_WalletManager_blockTarget: { + nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], + }, + MONERO_WalletManager_isMining: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wm_ptr: "pointer", + ], + }, + MONERO_WalletManager_startMining: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer", "u32", "bool", "bool"] as [ + wm_ptr: "pointer", + address: "pointer", + threads: "u32", + backgroundMining: "bool", + ignoreBattery: "bool", + ], + }, + MONERO_WalletManager_stopMining: { + nonblocking: true, + result: "bool", + parameters: ["pointer", "pointer"] as [ + wm_ptr: "pointer", + address: "pointer", + ], }, - "MONERO_PendingTransaction_signersKeys": { + MONERO_WalletManager_resolveOpenAlias: { nonblocking: true, - // void* pendingTx_ptr - parameters: ["pointer"], - // const char* result: "pointer", + parameters: ["pointer", "pointer", "bool"] as [ + wm_ptr: "pointer", + address: "pointer", + dnssec_valid: "bool", + ], }, - "MONERO_PendingTransaction_hex": { + MONERO_WalletManagerFactory_getWalletManager: { nonblocking: true, - // void* pendingTx_ptr, const char* separator - parameters: ["pointer", "pointer"], - // const char* result: "pointer", + parameters: [], }, - //#endregion - - //#region Checksum - "MONERO_checksum_wallet2_api_c_h": { + MONERO_WalletManagerFactory_setLogLevel: { + nonblocking: true, + result: "void", + parameters: ["i32"] as [ + level: "i32", + ], + }, + MONERO_WalletManagerFactory_setLogCategories: { optional: true, nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + categories: "pointer", + ], + }, + MONERO_DEBUG_test0: { + nonblocking: true, + result: "void", parameters: [], - // const char* + }, + MONERO_DEBUG_test1: { + nonblocking: true, + result: "bool", + parameters: ["bool"] as [ + x: "bool", + ], + }, + MONERO_DEBUG_test2: { + nonblocking: true, + result: "i32", + parameters: ["i32"] as [ + x: "i32", + ], + }, + MONERO_DEBUG_test3: { + nonblocking: true, + result: "u64", + parameters: ["u64"] as [ + x: "u64", + ], + }, + MONERO_DEBUG_test4: { + nonblocking: true, result: "pointer", + parameters: ["u64"] as [ + x: "u64", + ], }, - "MONERO_checksum_wallet2_api_c_cpp": { - optional: true, + MONERO_DEBUG_test5: { + nonblocking: true, + result: "pointer", + parameters: [], + }, + MONERO_DEBUG_test5_std: { nonblocking: true, + result: "pointer", parameters: [], - // const char* + }, + MONERO_DEBUG_isPointerNull: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_cw_getWalletListener: { + nonblocking: true, result: "pointer", + parameters: ["pointer"] as [ + wallet_ptr: "pointer", + ], + }, + MONERO_cw_WalletListener_resetNeedToRefresh: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + cw_walletListener_ptr: "pointer", + ], + }, + MONERO_cw_WalletListener_isNeedToRefresh: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + cw_walletListener_ptr: "pointer", + ], }, - "MONERO_checksum_wallet2_api_c_exp": { + MONERO_cw_WalletListener_isNewTransactionExist: { + nonblocking: true, + result: "bool", + parameters: ["pointer"] as [ + cw_walletListener_ptr: "pointer", + ], + }, + MONERO_cw_WalletListener_resetIsNewTransactionExist: { + nonblocking: true, + result: "void", + parameters: ["pointer"] as [ + cw_walletListener_ptr: "pointer", + ], + }, + MONERO_cw_WalletListener_height: { optional: true, nonblocking: true, + result: "u64", + parameters: ["pointer"] as [ + cw_walletListener_ptr: "pointer", + ], + }, + MONERO_checksum_wallet2_api_c_h: { + optional: true, + nonblocking: true, + result: "pointer", parameters: [], - // const char* + }, + MONERO_checksum_wallet2_api_c_cpp: { + optional: true, + nonblocking: true, result: "pointer", + parameters: [], }, - //#endregion - - "MONERO_free": { + MONERO_checksum_wallet2_api_c_exp: { + optional: true, + nonblocking: true, + result: "pointer", + parameters: [], + }, + MONERO_free: { nonblocking: true, - // void* ptr - parameters: ["pointer"], - // void result: "void", + parameters: ["pointer"] as [ + ptr: "pointer", + ], }, } as const; -type MoneroSymbols = typeof moneroSymbols; -export type MoneroTsDylib = Deno.DynamicLibrary<MoneroSymbols>; +export type MoneroSymbols = typeof moneroSymbols; type ReplaceMonero<T extends string> = T extends `MONERO${infer Y}` ? `WOWNERO${Y}` : never; +export type WowneroSymbols = { [Key in keyof MoneroSymbols as ReplaceMonero<Key>]: MoneroSymbols[Key] }; -type WowneroSymbols = { [Key in keyof MoneroSymbols as ReplaceMonero<Key>]: MoneroSymbols[Key] }; +export type SymbolName = keyof MoneroSymbols extends `MONERO_${infer SymbolName}` ? SymbolName : never; export const wowneroSymbols = Object.fromEntries( Object.entries(moneroSymbols).map(([key, value]) => [key.replace("MONERO", "WOWNERO"), value]), ) as WowneroSymbols; - -export type WowneroTsDylib = Deno.DynamicLibrary<WowneroSymbols>; - -export type Dylib = MoneroTsDylib | WowneroTsDylib; diff --git a/impls/monero.ts/src/transaction_history.ts b/impls/monero.ts/src/transaction_history.ts index aab64da..cec3fde 100644 --- a/impls/monero.ts/src/transaction_history.ts +++ b/impls/monero.ts/src/transaction_history.ts @@ -1,34 +1,41 @@ +import { fns } from "./bindings.ts"; import { TransactionInfo, TransactionInfoPtr } from "./transaction_info.ts"; -import { CString, getSymbol } from "./utils.ts"; +import { CString } from "./utils.ts"; export type TransactionHistoryPtr = Deno.PointerObject<"transactionHistory">; export class TransactionHistory { - #txHistoryPtr: TransactionHistoryPtr; + #ptr: TransactionHistoryPtr; - constructor(txHistoryPtr: TransactionHistoryPtr) { - this.#txHistoryPtr = txHistoryPtr; + #count!: number; + + constructor(ptr: TransactionHistoryPtr) { + this.#ptr = ptr; + } + + static async new(ptr: TransactionHistoryPtr) { + const instance = new TransactionHistory(ptr); + instance.#count = await fns.TransactionHistory_count(ptr); + return instance; } - async count(): Promise<number> { - return await getSymbol("TransactionHistory_count")(this.#txHistoryPtr); + get count(): number { + return this.#count; } async transaction(index: number): Promise<TransactionInfo> { - return new TransactionInfo( - ( - await getSymbol("TransactionHistory_transaction")(this.#txHistoryPtr, index) - ) as TransactionInfoPtr, + return TransactionInfo.new( + await fns.TransactionHistory_transaction(this.#ptr, index) as TransactionInfoPtr, ); } async refresh(): Promise<void> { - await getSymbol("TransactionHistory_refresh")(this.#txHistoryPtr); + await fns.TransactionHistory_refresh(this.#ptr); } async setTxNote(transactionId: string, note: string): Promise<void> { - await getSymbol("TransactionHistory_setTxNote")( - this.#txHistoryPtr, + await fns.TransactionHistory_setTxNote( + this.#ptr, CString(transactionId), CString(note), ); diff --git a/impls/monero.ts/src/transaction_info.ts b/impls/monero.ts/src/transaction_info.ts index 22ea0e7..9becfb9 100644 --- a/impls/monero.ts/src/transaction_info.ts +++ b/impls/monero.ts/src/transaction_info.ts @@ -1,104 +1,147 @@ -import { dylib } from "./bindings.ts"; -import { getSymbol, readCString, Sanitizer } from "./utils.ts"; +import { fns } from "./bindings.ts"; +import { C_SEPARATOR, CString, maybeMultipleStrings, readCString, SEPARATOR } from "./utils.ts"; -export type TransactionInfoPtr = Deno.PointerObject<"transactionInfo">; +export type TransactionInfoPtr = Deno.PointerObject<"pendingTransaction">; -export class TransactionInfo { - #txInfoPtr: TransactionInfoPtr; - sanitizer?: Sanitizer; - - constructor(txInfoPtr: TransactionInfoPtr, sanitizer?: Sanitizer) { - this.#txInfoPtr = txInfoPtr; - this.sanitizer = sanitizer; - } +export interface TransferData { + address: string | null; + amount: bigint; +} - async direction(): Promise<"in" | "out"> { - switch (await getSymbol("TransactionInfo_direction")(this.#txInfoPtr)) { - case 0: - return "in"; - case 1: - return "out"; - default: - await this.sanitizer?.(); - throw new Error("Invalid TransactionInfo direction"); +export class TransactionInfo<MultDest extends boolean = boolean> { + #ptr: TransactionInfoPtr; + + #amount!: bigint; + #fee!: bigint; + #timestamp!: bigint; + #transfersCount!: number; + #paymentId!: string | null; + #hash!: string | null; + + #subaddrAccount!: number; + #subaddrIndex!: string | null; + + #transfers!: readonly TransferData[]; + + constructor(ptr: TransactionInfoPtr) { + this.#ptr = ptr; + } + + static async new(ptr: TransactionInfoPtr): Promise<TransactionInfo> { + const instance = new TransactionInfo(ptr); + + const [amount, paymentId, fee, hash, subaddrIndex, subaddrAccount, timestamp, transfersCount] = await Promise.all([ + fns.TransactionInfo_amount(ptr), + fns.TransactionInfo_paymentId(ptr).then(readCString), + fns.TransactionInfo_fee(ptr), + fns.TransactionInfo_hash(ptr).then(readCString), + fns.TransactionInfo_subaddrIndex(ptr, C_SEPARATOR).then(readCString), + fns.TransactionInfo_subaddrAccount(ptr), + fns.TransactionInfo_timestamp(ptr), + fns.TransactionInfo_transfers_count(ptr), + ]); + + instance.#amount = amount; + instance.#fee = fee; + instance.#timestamp = timestamp; + instance.#transfersCount = transfersCount; + instance.#paymentId = paymentId; + instance.#hash = hash; + + instance.#subaddrAccount = subaddrAccount; + instance.#subaddrIndex = subaddrIndex; + + const transfers = []; + for (let i = 0; i < transfersCount; ++i) { + const [amount, address] = await Promise.all([ + fns.TransactionInfo_transfers_amount(ptr, i), + fns.TransactionInfo_transfers_address(ptr, i).then(readCString), + ]); + + transfers.push({ amount, address }); } - } + Object.freeze(transfers); + instance.#transfers = transfers; - async isPending(): Promise<boolean> { - return await getSymbol("TransactionInfo_isPending")(this.#txInfoPtr); + return instance; } - async isFailed(): Promise<boolean> { - return await getSymbol("TransactionInfo_isFailed")(this.#txInfoPtr); + get amount(): bigint { + return this.#amount; } - async isCoinbase(): Promise<boolean> { - return await getSymbol("TransactionInfo_isCoinbase")(this.#txInfoPtr); + get fee(): bigint { + return this.#fee; } - async amount(): Promise<bigint> { - return await getSymbol("TransactionInfo_amount")(this.#txInfoPtr); + get timestamp(): bigint { + return this.#timestamp; } - async fee(): Promise<bigint> { - return await getSymbol("TransactionInfo_fee")(this.#txInfoPtr); + get transfersCount(): number { + return this.#transfersCount; } - async blockHeight(): Promise<bigint> { - return await getSymbol("TransactionInfo_blockHeight")(this.#txInfoPtr); + get paymentId(): string | null { + return this.#paymentId; } - async description(): Promise<string> { - const description = await getSymbol("TransactionInfo_description")(this.#txInfoPtr); - return await readCString(description) || ""; + get hash(): string | null { + return this.#hash; } - async subaddrIndex(): Promise<string> { - const subaddrIndex = await getSymbol("TransactionInfo_subaddrIndex")(this.#txInfoPtr); - return await readCString(subaddrIndex) || ""; + get subaddrAccount(): number { + return this.#subaddrAccount; } - async subaddrAccount(): Promise<number> { - return await getSymbol("TransactionInfo_subaddrAccount")(this.#txInfoPtr); + get subaddrIndex(): string | null { + return this.#subaddrIndex; } - async label(): Promise<string> { - const label = await getSymbol("TransactionInfo_label")(this.#txInfoPtr); - return await readCString(label) || ""; + get transfers(): readonly TransferData[] { + return this.#transfers; } - async confirmations(): Promise<bigint> { - return await getSymbol("TransactionInfo_confirmations")(this.#txInfoPtr); + async direction(): Promise<"in" | "out"> { + switch (await fns.TransactionInfo_direction(this.#ptr)) { + case 0: + return "in"; + case 1: + return "out"; + default: + throw new Error("Invalid TransactionInfo direction"); + } } - async unlockTime(): Promise<bigint> { - return await getSymbol("TransactionInfo_unlockTime")(this.#txInfoPtr); + async description(): Promise<string | null> { + return await readCString( + await fns.TransactionInfo_description(this.#ptr), + ); } - async hash(): Promise<string> { - const hash = await getSymbol("TransactionInfo_hash")(this.#txInfoPtr); - return await readCString(hash) || ""; + async label(): Promise<string | null> { + return await readCString( + await fns.TransactionInfo_label(this.#ptr), + ); } - async timestamp(): Promise<bigint> { - return await getSymbol("TransactionInfo_timestamp")(this.#txInfoPtr); + async confirmations(): Promise<bigint> { + return await fns.TransactionInfo_confirmations(this.#ptr); } - async paymentId(): Promise<string> { - const paymentId = await getSymbol("TransactionInfo_paymentId")(this.#txInfoPtr); - return await readCString(paymentId) || ""; + async unlockTime(): Promise<bigint> { + return await fns.TransactionInfo_unlockTime(this.#ptr); } - async transfersCount(): Promise<number> { - return await getSymbol("TransactionInfo_transfers_count")(this.#txInfoPtr); + async isPending(): Promise<boolean> { + return await fns.TransactionInfo_isPending(this.#ptr); } - async transfersAmount(index: number): Promise<bigint> { - return await getSymbol("TransactionInfo_transfers_amount")(this.#txInfoPtr, index); + async isFailed(): Promise<boolean> { + return await fns.TransactionInfo_isFailed(this.#ptr); } - async transfersAddress(index: number): Promise<string> { - const transfersAddress = await getSymbol("TransactionInfo_transfers_address")(this.#txInfoPtr, index); - return await readCString(transfersAddress) || ""; + async isCoinbase(): Promise<boolean> { + return await fns.TransactionInfo_isCoinbase(this.#ptr); } } diff --git a/impls/monero.ts/src/unsigned_transaction.ts b/impls/monero.ts/src/unsigned_transaction.ts new file mode 100644 index 0000000..c5d8ed7 --- /dev/null +++ b/impls/monero.ts/src/unsigned_transaction.ts @@ -0,0 +1,79 @@ +import { fns } from "./bindings.ts"; +import { C_SEPARATOR, CString, maybeMultipleStrings, readCString } from "./utils.ts"; + +export type UnsignedTransactionPtr = Deno.PointerObject<"pendingTransaction">; + +export class UnsignedTransaction<MultDest extends boolean = false> { + #ptr: UnsignedTransactionPtr; + + #amount!: string | string[] | null; + #fee!: string | string[] | null; + #txCount!: bigint; + #paymentId!: string | null; + #recipientAddress!: string | string[] | null; + + constructor(ptr: UnsignedTransactionPtr) { + this.#ptr = ptr; + } + + async status(): Promise<number> { + return await fns.UnsignedTransaction_status(this.#ptr); + } + + async errorString(): Promise<string | null> { + return await readCString(await fns.UnsignedTransaction_errorString(this.#ptr)); + } + + static async new(ptr: UnsignedTransactionPtr): Promise<UnsignedTransaction> { + const instance = new UnsignedTransaction(ptr); + + const [amount, paymentId, fee, txCount, recipientAddress] = await Promise.all([ + fns.UnsignedTransaction_amount(ptr, C_SEPARATOR).then(readCString), + fns.UnsignedTransaction_paymentId(ptr, C_SEPARATOR).then(readCString), + fns.UnsignedTransaction_fee(ptr, C_SEPARATOR).then(readCString), + fns.UnsignedTransaction_txCount(ptr), + fns.UnsignedTransaction_recipientAddress(ptr, C_SEPARATOR).then(readCString), + ]); + + instance.#amount = maybeMultipleStrings(amount); + instance.#fee = maybeMultipleStrings(fee); + instance.#recipientAddress = maybeMultipleStrings(recipientAddress); + instance.#txCount = txCount; + instance.#paymentId = paymentId; + + return instance; + } + + get amount(): string | string[] | null { + return this.#amount; + } + + get fee(): string | string[] | null { + return this.#fee; + } + + get txCount(): bigint { + return this.#txCount; + } + + get paymentId(): string | null { + return this.#paymentId; + } + + get recipientAddress(): string | string[] | null { + return this.#recipientAddress; + } + + async sign(signedFileName: string): Promise<boolean> { + return await fns.UnsignedTransaction_sign(this.#ptr, CString(signedFileName)); + } + + async signUR(maxFragmentLength: number): Promise<string | null> { + const signUR = fns.UnsignedTransaction_signUR; + if (!signUR) return null; + + return await readCString( + await signUR(this.#ptr, maxFragmentLength), + ); + } +} diff --git a/impls/monero.ts/src/utils.ts b/impls/monero.ts/src/utils.ts index e88ddcd..4323b72 100644 --- a/impls/monero.ts/src/utils.ts +++ b/impls/monero.ts/src/utils.ts @@ -1,22 +1,19 @@ -import { dylib } from "../mod.ts"; -import type { moneroSymbols, MoneroTsDylib, WowneroTsDylib } from "./symbols.ts"; - -export type Sanitizer = () => void | PromiseLike<void>; +import { fns } from "./bindings.ts"; const textEncoder = new TextEncoder(); -export function CString(string: string): Deno.PointerValue<string> { - return Deno.UnsafePointer.of(textEncoder.encode(`${string}\x00`)); +export const SEPARATOR = ","; +export const C_SEPARATOR = CString(SEPARATOR); + +export function maybeMultipleStrings(input: string): string | string[]; +export function maybeMultipleStrings(input: null | string): null | string | string[]; +export function maybeMultipleStrings(input: null | string): null | string | string[] { + if (!input) return null; + const multiple = input.split(SEPARATOR); + return multiple.length === 1 ? multiple[0] : multiple; } -type SymbolWithoutPrefix = keyof typeof moneroSymbols extends `MONERO_${infer DylibSymbol}` ? DylibSymbol : never; -export function getSymbol<S extends SymbolWithoutPrefix>( - symbol: S, -): MoneroTsDylib["symbols"][`MONERO_${S}`] | WowneroTsDylib["symbols"][`WOWNERO_${S}`] { - if ("MONERO_free" in dylib.symbols) { - return dylib.symbols[`MONERO_${symbol}` as const]; - } else { - return dylib.symbols[`WOWNERO_${symbol}` as const]; - } +export function CString(string: string): Deno.PointerValue<string> { + return Deno.UnsafePointer.of(textEncoder.encode(`${string}\x00`)); } /** @@ -29,9 +26,8 @@ export async function readCString(pointer: Deno.PointerObject, free?: boolean): export async function readCString(pointer: Deno.PointerValue, free?: boolean): Promise<string | null>; export async function readCString(pointer: Deno.PointerValue, free = true): Promise<string | null> { if (!pointer) return null; + const string = new Deno.UnsafePointerView(pointer).getCString(); - if (free) { - await getSymbol("free")(pointer); - } + if (string && free) await fns.free(pointer); return string; } diff --git a/impls/monero.ts/src/wallet.ts b/impls/monero.ts/src/wallet.ts index ea25f21..92832da 100644 --- a/impls/monero.ts/src/wallet.ts +++ b/impls/monero.ts/src/wallet.ts @@ -1,294 +1,268 @@ -import { dylib } from "./bindings.ts"; -import { CString, getSymbol, readCString, Sanitizer } from "./utils.ts"; +import { WalletManager } from "./wallet_manager.ts"; -import { WalletManager, type WalletManagerPtr } from "./wallet_manager.ts"; -import { TransactionHistory, TransactionHistoryPtr } from "./transaction_history.ts"; -import { PendingTransaction } from "./pending_transaction.ts"; -import { PendingTransactionPtr } from "./pending_transaction.ts"; +import { C_SEPARATOR, CString, readCString, SEPARATOR } from "./utils.ts"; +import { PendingTransaction, PendingTransactionPtr } from "./pending_transaction.ts"; +import { UnsignedTransaction, UnsignedTransactionPtr } from "./unsigned_transaction.ts"; +import { Coins, CoinsPtr } from "./coins.ts"; +import { fns } from "./bindings.ts"; export type WalletPtr = Deno.PointerObject<"walletManager">; +interface DaemonInfo { + address?: string; + username?: string; + password?: string; + lightWallet?: boolean; + proxyAddress?: string; +} + export class Wallet { - #walletManagerPtr: WalletManagerPtr; - #walletPtr: WalletPtr; - sanitizer?: Sanitizer; + #walletManager: WalletManager; + #ptr: WalletPtr; - constructor(walletManagerPtr: WalletManager, walletPtr: WalletPtr, sanitizer?: Sanitizer) { - this.#walletPtr = walletPtr; - this.#walletManagerPtr = walletManagerPtr.getPointer(); - this.sanitizer = sanitizer; + constructor(walletManager: WalletManager, ptr: WalletPtr) { + this.#walletManager = walletManager; + this.#ptr = ptr; } - getPointer(): WalletPtr { - return this.#walletPtr; + getPointer() { + return this.#ptr; } - async store(path = ""): Promise<boolean> { - const bool = await getSymbol("Wallet_store")(this.#walletPtr, CString(path)); - await this.throwIfError(); - return bool; - } + async init(daemonInfo: DaemonInfo, log = false): Promise<boolean> { + const success = await fns.Wallet_init( + this.#ptr, + CString(daemonInfo.address ?? ""), + 0n, + CString(daemonInfo.username ?? ""), + CString(daemonInfo.password ?? ""), + false, + daemonInfo.lightWallet ?? false, + CString(daemonInfo.proxyAddress ?? ""), + ); + + if (log) { + await fns.Wallet_init3( + this.#ptr, + CString(""), + CString(""), + CString(""), + true, + ); + } - async initWallet(daemonAddress = "http://nodex.monerujo.io:18081"): Promise<void> { - await this.init(); await this.setTrustedDaemon(true); - await this.setDaemonAddress(daemonAddress); await this.startRefresh(); await this.refreshAsync(); - await this.throwIfError(); + + return success; } - async setDaemonAddress(address: string): Promise<void> { - await getSymbol("WalletManager_setDaemonAddress")( - this.#walletManagerPtr, - CString(address), - ); + async setTrustedDaemon(value: boolean): Promise<void> { + return await fns.Wallet_setTrustedDaemon(this.#ptr, value); } async startRefresh(): Promise<void> { - await getSymbol("Wallet_startRefresh")(this.#walletPtr); - await this.throwIfError(); + return await fns.Wallet_startRefresh(this.#ptr); } async refreshAsync(): Promise<void> { - await getSymbol("Wallet_refreshAsync")(this.#walletPtr); - await this.throwIfError(); - } - - async init(): Promise<boolean> { - const bool = await getSymbol("Wallet_init")( - this.#walletPtr, - CString("http://nodex.monerujo.io:18081"), - 0n, - CString(""), - CString(""), - false, - false, - CString(""), + return await fns.Wallet_refreshAsync(this.#ptr); + } + + async setupBackgroundSync( + backgroundSyncType: number, + walletPassword: string, + backgroundCachePassword: string, + ): Promise<boolean> { + return await fns.Wallet_setupBackgroundSync( + this.#ptr, + backgroundSyncType, + CString(walletPassword), + CString(backgroundCachePassword), ); - await this.throwIfError(); - return bool; } - async setTrustedDaemon(value: boolean): Promise<void> { - await getSymbol("Wallet_setTrustedDaemon")(this.#walletPtr, value); - } - - static async create( - walletManager: WalletManager, - path: string, - password: string, - sanitizeError = true, - ): Promise<Wallet> { - // We assign holder of the pointer in Wallet constructor - const walletManagerPtr = walletManager.getPointer(); - - const walletPtr = await getSymbol("WalletManager_createWallet")( - walletManagerPtr, - CString(path), - CString(password), - CString("English"), - 0, - ); + async startBackgroundSync(): Promise<boolean> { + return await fns.Wallet_startBackgroundSync(this.#ptr); + } - const wallet = new Wallet(walletManager, walletPtr as WalletPtr, walletManager.sanitizer); - await wallet.throwIfError(sanitizeError); - await wallet.initWallet(); + async stopBackgroundSync(walletPassword: string): Promise<boolean> { + return await fns.Wallet_stopBackgroundSync(this.#ptr, CString(walletPassword)); + } - return wallet; + async store(path = ""): Promise<boolean> { + return await fns.Wallet_store(this.#ptr, CString(path)); } - static async open( - walletManager: WalletManager, - path: string, - password: string, - sanitizeError = true, - ): Promise<Wallet> { - // We assign holder of the pointer in Wallet constructor - const walletManagerPtr = walletManager.getPointer(); + async close(store: boolean): Promise<boolean> { + return await fns.WalletManager_closeWallet(this.#walletManager.getPointer(), this.#ptr, store); + } - const walletPtr = await getSymbol("WalletManager_openWallet")( - walletManagerPtr, - CString(path), - CString(password), - 0, + async seed(offset = ""): Promise<string | null> { + return await readCString( + await fns.Wallet_seed(this.#ptr, CString(offset)), ); + } - const wallet = new Wallet(walletManager, walletPtr as WalletPtr, walletManager.sanitizer); - await wallet.throwIfError(sanitizeError); - await wallet.initWallet(); - - return wallet; - } - - static async recover( - walletManager: WalletManager, - path: string, - password: string, - mnemonic: string, - restoreHeight: bigint, - seedOffset: string = "", - sanitizeError = true, - ): Promise<Wallet> { - // We assign holder of the pointer in Wallet constructor - const walletManagerPtr = walletManager.getPointer(); - - const walletPtr = await getSymbol("WalletManager_recoveryWallet")( - walletManagerPtr, - CString(path), - CString(password), - CString(mnemonic), - 0, - restoreHeight, - 1n, - CString(seedOffset), + async address(accountIndex = 0n, addressIndex = 0n): Promise<string | null> { + return await readCString( + await fns.Wallet_address(this.#ptr, accountIndex, addressIndex), ); + } - const wallet = new Wallet(walletManager, walletPtr as WalletPtr, walletManager.sanitizer); - await wallet.throwIfError(sanitizeError); - await wallet.initWallet(); + async balance(accountIndex = 0): Promise<bigint> { + return await fns.Wallet_balance(this.#ptr, accountIndex); + } - return wallet; + async unlockedBalance(accountIndex = 0): Promise<bigint> { + return await fns.Wallet_unlockedBalance(this.#ptr, accountIndex); } - async address(accountIndex = 0n, addressIndex = 0n): Promise<string> { - const address = await getSymbol("Wallet_address")(this.#walletPtr, accountIndex, addressIndex); - if (!address) { - const error = await this.errorString(); - throw new Error(`Failed getting address from a wallet: ${error ?? "<Error unknown>"}`); - } - return await readCString(address); + async synchronized(): Promise<boolean> { + return await fns.Wallet_synchronized(this.#ptr); } - async balance(accountIndex = 0): Promise<bigint> { - return await getSymbol("Wallet_balance")(this.#walletPtr, accountIndex); + async blockChainHeight(): Promise<bigint> { + return await fns.Wallet_blockChainHeight(this.#ptr); } - async unlockedBalance(accountIndex = 0): Promise<bigint> { - return await getSymbol("Wallet_unlockedBalance")(this.#walletPtr, accountIndex); + async daemonBlockChainHeight(): Promise<bigint> { + return await fns.Wallet_daemonBlockChainHeight(this.#ptr); } - status(): Promise<number> { - return getSymbol("Wallet_status")(this.#walletPtr); + async addSubaddressAccount(label: string): Promise<void> { + return await fns.Wallet_addSubaddressAccount(this.#ptr, CString(label)); } - async errorString(): Promise<string | null> { - if (!await this.status()) return null; + async numSubaddressAccounts(): Promise<bigint> { + return await fns.Wallet_numSubaddressAccounts(this.#ptr); + } - const error = await getSymbol("Wallet_errorString")(this.#walletPtr); - if (!error) return null; + async addSubaddress(accountIndex: number, label: string): Promise<void> { + return await fns.Wallet_addSubaddress( + this.#ptr, + accountIndex, + CString(label), + ); + } - return await readCString(error) || null; + async numSubaddresses(accountIndex: number): Promise<bigint> { + return await fns.Wallet_numSubaddresses( + this.#ptr, + accountIndex, + ); } - async throwIfError(sanitize = true): Promise<void> { - const maybeError = await this.errorString(); - if (maybeError) { - if (sanitize) this.sanitizer?.(); - throw new Error(maybeError); - } + async getSubaddressLabel(accountIndex: number, addressIndex: number): Promise<string | null> { + return await readCString( + await fns.Wallet_getSubaddressLabel(this.#ptr, accountIndex, addressIndex), + ); } - async synchronized(): Promise<boolean> { - const synchronized = await getSymbol("Wallet_synchronized")(this.#walletPtr); - await this.throwIfError(); - return synchronized; + async setSubaddressLabel(accountIndex: number, addressIndex: number, label: string): Promise<void> { + return await fns.Wallet_setSubaddressLabel(this.#ptr, accountIndex, addressIndex, CString(label)); } - async blockChainHeight(): Promise<bigint> { - const height = await getSymbol("Wallet_blockChainHeight")(this.#walletPtr); - await this.throwIfError(); - return height; + async isOffline(): Promise<boolean> { + return await fns.Wallet_isOffline(this.#ptr); } - async daemonBlockChainHeight(): Promise<bigint> { - const height = await getSymbol("Wallet_daemonBlockChainHeight")(this.#walletPtr); - await this.throwIfError(); - return height; + async setOffline(offline: boolean): Promise<void> { + return await fns.Wallet_setOffline(this.#ptr, offline); } - async managerBlockChainHeight(): Promise<bigint> { - const height = await getSymbol("WalletManager_blockchainHeight")(this.#walletManagerPtr); - await this.throwIfError(); - return height; + async publicViewKey(): Promise<string | null> { + return await readCString(await fns.Wallet_publicViewKey(this.#ptr)); } - async managerTargetBlockChainHeight(): Promise<bigint> { - const height = await getSymbol("WalletManager_blockchainTargetHeight")(this.#walletManagerPtr); - await this.throwIfError(); - return height; + async secretViewKey(): Promise<string | null> { + return await readCString(await fns.Wallet_secretViewKey(this.#ptr)); } - async addSubaddressAccount(label: string): Promise<void> { - await getSymbol("Wallet_addSubaddressAccount")( - this.#walletPtr, - CString(label), - ); - await this.throwIfError(); + async publicSpendKey(): Promise<string | null> { + return await readCString(await fns.Wallet_publicSpendKey(this.#ptr)); } - async numSubaddressAccounts(): Promise<bigint> { - const accountsLen = await getSymbol("Wallet_numSubaddressAccounts")(this.#walletPtr); - await this.throwIfError(); - return accountsLen; + async secretSpendKey(): Promise<string | null> { + return await readCString(await fns.Wallet_secretSpendKey(this.#ptr)); } - async addSubaddress(accountIndex: number, label: string): Promise<void> { - await getSymbol("Wallet_addSubaddress")( - this.#walletPtr, - accountIndex, - CString(label), - ); - await this.throwIfError(); + async exportOutputs(fileName: string, all: boolean): Promise<boolean> { + return await fns.Wallet_exportOutputs(this.#ptr, CString(fileName), all); } - async numSubaddresses(accountIndex: number): Promise<bigint> { - const address = await getSymbol("Wallet_numSubaddresses")( - this.#walletPtr, - accountIndex, + async exportOutputsUR(maxFragmentLength: bigint, all: boolean): Promise<string | null> { + const exportOutputsUR = fns.Wallet_exportOutputsUR; + if (!exportOutputsUR) return null; + + return await readCString( + await exportOutputsUR(this.#ptr, maxFragmentLength, all), ); - await this.throwIfError(); - return address; } - async getSubaddressLabel(accountIndex: number, addressIndex: number): Promise<string> { - const label = await getSymbol("Wallet_getSubaddressLabel")(this.#walletPtr, accountIndex, addressIndex); - if (!label) { - const error = await this.errorString(); - throw new Error(`Failed getting subaddress label from a wallet: ${error ?? "<Error unknown>"}`); - } - return await readCString(label); + async importOutputs(fileName: string): Promise<boolean> { + return await fns.Wallet_importOutputs(this.#ptr, CString(fileName)); } - async setSubaddressLabel(accountIndex: number, addressIndex: number, label: string): Promise<void> { - await getSymbol("Wallet_setSubaddressLabel")( - this.#walletPtr, - accountIndex, - addressIndex, - CString(label), + async importOutputsUR(input: string): Promise<boolean | null> { + const importOutputsUR = fns.Wallet_importOutputsUR; + if (!importOutputsUR) return null; + + return await importOutputsUR(this.#ptr, CString(input)); + } + + async exportKeyImages(fileName: string, all: boolean): Promise<boolean> { + return await fns.Wallet_exportKeyImages(this.#ptr, CString(fileName), all); + } + + async exportKeyImagesUR(maxFragmentLength: bigint, all: boolean): Promise<string | null> { + const exportKeyImagesUR = fns.Wallet_exportKeyImagesUR; + if (!exportKeyImagesUR) return null; + + return await readCString( + await exportKeyImagesUR(this.#ptr, maxFragmentLength, all), ); - await this.throwIfError(); } - async getHistory(): Promise<TransactionHistory> { - const transactionHistoryPointer = await getSymbol("Wallet_history")(this.#walletPtr); - await this.throwIfError(); - return new TransactionHistory(transactionHistoryPointer as TransactionHistoryPtr); + async importKeyImages(fileName: string): Promise<boolean> { + return await fns.Wallet_importKeyImages(this.#ptr, CString(fileName)); + } + + async importKeyImagesUR(input: string): Promise<boolean | null> { + const importKeyImagesUR = fns.Wallet_importKeyImagesUR; + if (!importKeyImagesUR) return null; + + return await importKeyImagesUR(this.#ptr, CString(input)); + } + + async loadUnsignedTx(fileName: string): Promise<UnsignedTransaction> { + const pendingTxPtr = await fns.Wallet_loadUnsignedTx(this.#ptr, CString(fileName)); + return UnsignedTransaction.new(pendingTxPtr as UnsignedTransactionPtr); + } + + async loadUnsignedTxUR(input: string): Promise<UnsignedTransaction | null> { + const loadUnsignedTxUR = fns.Wallet_loadUnsignedTxUR; + if (!loadUnsignedTxUR) return null; + + const pendingTxPtr = await loadUnsignedTxUR(this.#ptr, CString(input)); + if (await this.status()) { + throw this.errorString(); + } + return UnsignedTransaction.new(pendingTxPtr as UnsignedTransactionPtr); } async createTransaction( destinationAddress: string, amount: bigint, - pendingTransactionPriority = 0 | 1 | 2 | 3, + pendingTransactionPriority: 0 | 1 | 2 | 3, subaddressAccount: number, - sanitize = true, prefferedInputs = "", mixinCount = 0, paymentId = "", - separator = ",", - ): Promise<PendingTransaction> { - const pendingTxPtr = await getSymbol("Wallet_createTransaction")( - this.#walletPtr, + ): Promise<PendingTransaction | null> { + const pendingTxPtr = await fns.Wallet_createTransaction( + this.#ptr, CString(destinationAddress), CString(paymentId), amount, @@ -296,13 +270,63 @@ export class Wallet { pendingTransactionPriority, subaddressAccount, CString(prefferedInputs), - CString(separator), + C_SEPARATOR, + ); + + if (!pendingTxPtr) return null; + return PendingTransaction.new(pendingTxPtr as PendingTransactionPtr); + } + + async createTransactionMultDest( + destinationAddresses: string[], + amounts: bigint[], + amountSweepAll: boolean, + pendingTransactionPriority: 0 | 1 | 2 | 3, + subaddressAccount: number, + preferredInputs: string[] = [], + mixinCount = 0, + paymentId = "", + ): Promise<PendingTransaction | null> { + const pendingTxPtr = await fns.Wallet_createTransactionMultDest?.( + this.#ptr, + CString(destinationAddresses.join(SEPARATOR)), + C_SEPARATOR, + CString(paymentId), + amountSweepAll, + CString(amounts.join(SEPARATOR)), + C_SEPARATOR, + mixinCount, + pendingTransactionPriority, + subaddressAccount, + CString(preferredInputs.join(SEPARATOR)), + C_SEPARATOR, ); - await this.throwIfError(sanitize); - return new PendingTransaction(pendingTxPtr as PendingTransactionPtr); + + if (!pendingTxPtr) return null; + return PendingTransaction.new(pendingTxPtr as PendingTransactionPtr); } - async amountFromString(amount: string): Promise<bigint> { - return await getSymbol("Wallet_amountFromString")(CString(amount)); + async coins(): Promise<Coins | null> { + const coinsPtr = await fns.Wallet_coins(this.#ptr); + if (!coinsPtr) return null; + + return new Coins(coinsPtr as CoinsPtr); + } + + async status(): Promise<number> { + return await fns.Wallet_status(this.#ptr); + } + + async errorString(): Promise<string | null> { + if (!await this.status()) return null; + const error = await fns.Wallet_errorString(this.#ptr); + return await readCString(error); + } + + async throwIfError(): Promise<void> { + const maybeError = await this.errorString(); + if (maybeError) { + throw new Error(maybeError); + } } } diff --git a/impls/monero.ts/src/wallet_manager.ts b/impls/monero.ts/src/wallet_manager.ts index b1fafec..45fd0c9 100644 --- a/impls/monero.ts/src/wallet_manager.ts +++ b/impls/monero.ts/src/wallet_manager.ts @@ -1,26 +1,148 @@ -import { getSymbol, Sanitizer } from "./utils.ts"; +import { fns } from "./bindings.ts"; +import { CString } from "./utils.ts"; +import { Wallet, WalletPtr } from "./wallet.ts"; export type WalletManagerPtr = Deno.PointerObject<"walletManager">; export class WalletManager { #ptr: WalletManagerPtr; - sanitizer?: Sanitizer; - constructor(walletManagerPtr: WalletManagerPtr, sanitizer?: Sanitizer) { + constructor(walletManagerPtr: WalletManagerPtr) { this.#ptr = walletManagerPtr; - this.sanitizer = sanitizer; } getPointer(): WalletManagerPtr { return this.#ptr; } - static async new(sanitizer?: Sanitizer) { - const ptr = await getSymbol("WalletManagerFactory_getWalletManager")(); + static async new() { + const ptr = await fns.WalletManagerFactory_getWalletManager(); if (!ptr) { - sanitizer?.(); throw new Error("Failed retrieving wallet manager"); } - return new WalletManager(ptr as WalletManagerPtr, sanitizer); + + return new WalletManager(ptr as WalletManagerPtr); + } + + async setDaemonAddress(address: string): Promise<void> { + return await fns.WalletManager_setDaemonAddress(this.#ptr, CString(address)); + } + + async createWallet(path: string, password: string): Promise<Wallet> { + const walletPtr = await fns.WalletManager_createWallet( + this.#ptr, + CString(path), + CString(password), + CString("English"), + 0, + ); + + const wallet = new Wallet(this, walletPtr as WalletPtr); + await wallet.throwIfError(); + return wallet; + } + + async openWallet(path: string, password: string): Promise<Wallet> { + const walletPtr = await fns.WalletManager_openWallet( + this.#ptr, + CString(path), + CString(password), + 0, + ); + + const wallet = new Wallet(this, walletPtr as WalletPtr); + await wallet.throwIfError(); + return wallet; + } + + async recoverWallet( + path: string, + password: string, + mnemonic: string, + restoreHeight: bigint, + seedOffset: string = "", + ): Promise<Wallet> { + const walletPtr = await fns.WalletManager_recoveryWallet( + this.#ptr, + CString(path), + CString(password), + CString(mnemonic), + 0, + restoreHeight, + 1n, + CString(seedOffset), + ); + + const wallet = new Wallet(this, walletPtr as WalletPtr); + await wallet.throwIfError(); + return wallet; + } + + async recoverFromPolyseed( + path: string, + password: string, + mnemonic: string, + restoreHeight: bigint, + passphrase = "", + ): Promise<Wallet> { + return await this.createFromPolyseed( + path, + password, + mnemonic, + restoreHeight, + passphrase, + false, + ); + } + + async createFromPolyseed( + path: string, + password: string, + mnemonic: string, + restoreHeight: bigint, + passphrase = "", + newWallet = true, + ): Promise<Wallet> { + const walletPtr = await fns.WalletManager_createWalletFromPolyseed( + this.#ptr, + CString(path), + CString(password), + 0, + CString(mnemonic), + CString(passphrase), + newWallet, + restoreHeight, + 1n, + ); + + const wallet = new Wallet(this, walletPtr as WalletPtr); + await wallet.throwIfError(); + return wallet; + } + + async recoverFromKeys( + path: string, + password: string, + restoreHeight: bigint, + address: string, + viewKey: string, + spendKey: string, + ): Promise<Wallet> { + const walletPtr = await fns.WalletManager_createWalletFromKeys( + this.#ptr, + CString(path), + CString(password), + CString("English"), + 0, + restoreHeight, + CString(address), + CString(viewKey), + CString(spendKey), + 0n, + ); + + const wallet = new Wallet(this, walletPtr as WalletPtr); + await wallet.throwIfError(); + return wallet; } } |