Merge remote-tracking branch 'origin/develop' into rust-develop

12 files changed, 1263 insertions, 115 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