Embed monero.dart into monero_c (#16)

1 files changed, 3614 insertions, 0 deletions

diff --git a/impls/monero.dart/lib/wownero.dart b/impls/monero.dart/lib/wownero.dart
new file mode 100644
index 0000000..2f9252d
--- /dev/null
+++ b/impls/monero.dart/lib/wownero.dart
@@ -0,0 +1,3614 @@
+library;
+
+// Are we memory safe?
+// There is a simple way to check that:
+// 1) Rewrite everything in rust
+// Or, assuming we are sane
+// 1) grep -E 'toNative|^String ' lib/wownero.dart | grep -v '^//' | grep -v '^String libPath = ' | wc -l
+//    This will print number of all things that produce pointers
+// 2) grep .free lib/wownero.dart | grep -v '^//' | wc -l
+//    This will print number of all free calls, these numbers should match
+
+// Wrapper around generated_bindings.g.dart - to provide easy access to the
+// underlying functions, feel free to not use it at all.
+
+//  _____________ PendingTransaction is just a typedef for Pointer<Void> (which is void* on C side)
+// /                   _____________ Wallet class, we didn't specify the MONERO prefix because we import the monero.dart code with monero prefix
+// |                  /       _____________ createTransaction function, from the upstream in the class Wallet
+// |                  |      /
+// PendingTransaction Wallet_createTransaction(wallet ptr, <------------- wallet is a typedef for Pointer<Void>
+//     {required String dst_addr,--------------------------------\ All of the parameters that are used in this function
+//     required String payment_id,                  _____________/ String - will get casted into const char*
+//     required int amount,                        /
+//     required int mixin_count,                  /                int - goes as it is
+//     required int pendingTransactionPriority,  /
+//     required int subaddr_account,            /
+//     List<String> preferredInputs = const []}) {                 List<String> - gets joined and passed as 2 separate parameters to be split in the C side____
+//   debugStart?.call('WOWNERO_Wallet_createTransaction'); <------------- debugStart functions just marks the function as currently being executed, used        |
+//   lib ??= WowneroC(DynamicLibrary.open(libPath));                    \_for performance debugging                                                             |
+//   \_____________ Load the library in case it is not loaded                                                                                                  |
+//   final dst_addr_ = dst_addr.toNativeUtf8().cast<Char>(); -----------------| Cast the strings into Chars so it can be used as a parameter in a function     |
+//   final payment_id_ = payment_id.toNativeUtf8().cast<Char>(); -------------| generated via ffigen                                                           |
+//   final preferredInputs_ = preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast<Char>(); <---------------------------------------------------------/
+//   final s = lib!.WOWNERO_Wallet_createTransaction(-------------|
+//     ptr,                                                       |
+//     dst_addr_,                                                 |
+//     payment_id_,                                               |
+//     amount,                                                    |
+//     mixin_count,                                               | Call the native function using generated code
+//     pendingTransactionPriority,                                |
+//     subaddr_account,                                           |
+//     preferredInputs_,                                          |
+//     defaultSeparator,                                          |
+//   );___________________________________________________________/
+//   calloc.free(dst_addr_);---------------| Free the memory once we don't need it
+//   calloc.free(payment_id_);-------------|
+//   debugEnd?.call('WOWNERO_Wallet_createTransaction'); <------------- Mark the function as executed
+//   return s; <------------- return the value
+// }
+//
+// Extra case is happening when we have a function call that returns const char* as we have to be memory safe
+// String PendingTransaction_txid(PendingTransaction ptr, String separator) {
+//   debugStart?.call('WOWNERO_PendingTransaction_txid');
+//   lib ??= WowneroC(DynamicLibrary.open(libPath));
+//   final separator_ = separator.toNativeUtf8().cast<Char>();
+//   final txid = lib!.WOWNERO_PendingTransaction_txid(ptr, separator_);
+//   calloc.free(separator_);
+//   debugEnd?.call('WOWNERO_PendingTransaction_txid');
+//   try { <------------- We need to try-catch these calls because they may fail in an unlikely case when we get an invalid UTF-8 string,
+//     final strPtr = txid.cast<Utf8>();                                            it is better to throw than to crash main isolate imo.
+//     final str = strPtr.toDartString(); <------------- convert the pointer to const char* to dart String
+//     WOWNERO_free(strPtr.cast()); <------------- free the memory
+//     debugEnd?.call('WOWNERO_PendingTransaction_txid');
+//     return str; <------------- return the value
+//   } catch (e) {
+//     errorHandler?.call('WOWNERO_PendingTransaction_txid', e);
+//     debugEnd?.call('WOWNERO_PendingTransaction_txid');
+//     return ""; <------------- return an empty string in case of an error.
+//   }
+// }
+//
+
+// 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_wownero.g.dart';
+
+typedef PendingTransaction = Pointer<Void>;
+
+WowneroC? lib;
+String libPath = (() {
+  if (Platform.isWindows) return 'wownero_libwallet2_api_c.dll';
+  if (Platform.isMacOS) return 'wownero_libwallet2_api_c.dylib';
+  if (Platform.isIOS) return 'WowneroWallet.framework/WowneroWallet';
+  if (Platform.isAndroid) return 'libwownero_libwallet2_api_c.so';
+  return 'wownero_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) {
+  if (printStarts) print("MONERO: $call");
+  debugCallLength[call] ??= <int>[];
+  debugCallLength[call]!.add(sw.elapsedMicroseconds);
+};
+void Function(String call)? debugEnd = (call) {
+  final id = debugCallLength[call]!.length - 1;
+  debugCallLength[call]![id] =
+      sw.elapsedMicroseconds - debugCallLength[call]![id];
+};
+void Function(String call, dynamic error)? errorHandler = (call, error) {
+  print("$call: $error");
+};
+
+int PendingTransaction_status(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_status');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_PendingTransaction_status(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_status');
+  return status;
+}
+
+String PendingTransaction_errorString(PendingTransaction ptr) {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  debugStart?.call('WOWNERO_PendingTransaction_errorString');
+  try {
+    final rPtr = lib!.WOWNERO_PendingTransaction_errorString(ptr).cast<Utf8>();
+    final str = rPtr.toDartString();
+    WOWNERO_free(rPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_errorString', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_errorString');
+    return "";
+  }
+}
+
+bool PendingTransaction_commit(PendingTransaction ptr,
+    {required String filename, required bool overwrite}) {
+  debugStart?.call('WOWNERO_PendingTransaction_commit');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final result =
+      lib!.WOWNERO_PendingTransaction_commit(ptr, filename_, overwrite);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_PendingTransaction_commit');
+  return result;
+}
+
+int PendingTransaction_amount(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final amount = lib!.WOWNERO_PendingTransaction_amount(ptr);
+  debugStart?.call('WOWNERO_PendingTransaction_amount');
+  return amount;
+}
+
+int PendingTransaction_dust(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_dust');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dust = lib!.WOWNERO_PendingTransaction_dust(ptr);
+  debugStart?.call('WOWNERO_PendingTransaction_dust');
+  return dust;
+}
+
+int PendingTransaction_fee(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_fee');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final fee = lib!.WOWNERO_PendingTransaction_fee(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_fee');
+  return fee;
+}
+
+String PendingTransaction_txid(PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_txid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_txid(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_txid');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_txid');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_txid', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_txid');
+    return "";
+  }
+}
+
+int PendingTransaction_txCount(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_txCount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txCount = lib!.WOWNERO_PendingTransaction_txCount(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_txCount');
+  return txCount;
+}
+
+String PendingTransaction_subaddrAccount(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_subaddrAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_subaddrAccount(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_subaddrAccount', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount');
+    return "";
+  }
+}
+
+String PendingTransaction_subaddrIndices(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_subaddrIndices');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_subaddrIndices(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_subaddrIndices', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices');
+    return "";
+  }
+}
+
+String PendingTransaction_multisigSignData(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_multisigSignData');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid = lib!.WOWNERO_PendingTransaction_multisigSignData(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_multisigSignData');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_multisigSignData');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_multisigSignData', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_multisigSignData');
+    return "";
+  }
+}
+
+void PendingTransaction_signMultisigTx(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_signMultisigTx');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.WOWNERO_PendingTransaction_signMultisigTx(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_signMultisigTx');
+  return ret;
+}
+
+String PendingTransaction_signersKeys(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_signersKeys');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_signersKeys(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_signersKeys');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    debugEnd?.call('WOWNERO_PendingTransaction_signersKeys');
+    WOWNERO_free(strPtr.cast());
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_signersKeys', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_signersKeys');
+    return "";
+  }
+}
+
+String PendingTransaction_hex(PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_hex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_hex(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_hex');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    debugEnd?.call('WOWNERO_PendingTransaction_hex');
+    WOWNERO_free(strPtr.cast());
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_hex', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_hex');
+    return "";
+  }
+}
+
+// UnsignedTransaction
+
+typedef UnsignedTransaction = Pointer<Void>;
+
+int UnsignedTransaction_status(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_status');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dust = lib!.WOWNERO_UnsignedTransaction_status(ptr);
+  debugStart?.call('WOWNERO_UnsignedTransaction_status');
+  return dust;
+}
+
+String UnsignedTransaction_errorString(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_errorString');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString = lib!.WOWNERO_UnsignedTransaction_errorString(ptr);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_errorString', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_errorString');
+    return "";
+  }
+}
+
+String UnsignedTransaction_amount(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_amount');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_amount(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_amount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_amount', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_amount');
+    return "";
+  }
+}
+
+String UnsignedTransaction_fee(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_fee');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_fee(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_fee');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_fee', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_fee');
+    return "";
+  }
+}
+
+String UnsignedTransaction_mixin(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_mixin');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_mixin(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_mixin');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_mixin', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_mixin');
+    return "";
+  }
+}
+
+String UnsignedTransaction_confirmationMessage(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_confirmationMessage');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString = lib!.WOWNERO_UnsignedTransaction_confirmationMessage(ptr);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_confirmationMessage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_confirmationMessage', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_confirmationMessage');
+    return "";
+  }
+}
+
+String UnsignedTransaction_paymentId(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_paymentId');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_paymentId(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_paymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_paymentId', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_paymentId');
+    return "";
+  }
+}
+
+String UnsignedTransaction_recipientAddress(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_recipientAddress');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_recipientAddress(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_recipientAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_recipientAddress', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_recipientAddress');
+    return "";
+  }
+}
+
+int UnsignedTransaction_minMixinCount(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_minMixinCount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_UnsignedTransaction_minMixinCount(ptr);
+  debugStart?.call('WOWNERO_UnsignedTransaction_minMixinCount');
+  return v;
+}
+
+int UnsignedTransaction_txCount(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_txCount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_UnsignedTransaction_txCount(ptr);
+  debugStart?.call('WOWNERO_UnsignedTransaction_txCount');
+  return v;
+}
+
+bool UnsignedTransaction_sign(UnsignedTransaction ptr, String signedFileName) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_sign');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final signedFileName_ = signedFileName.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_UnsignedTransaction_sign(ptr, signedFileName_);
+  calloc.free(signedFileName_);
+  debugStart?.call('WOWNERO_UnsignedTransaction_sign');
+  return v;
+}
+// TransactionInfo
+
+typedef TransactionInfo = Pointer<Void>;
+
+enum TransactionInfo_Direction { In, Out }
+
+TransactionInfo_Direction TransactionInfo_direction(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_direction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final tiDir = TransactionInfo_Direction
+      .values[lib!.WOWNERO_TransactionInfo_direction(ptr)];
+  debugEnd?.call('WOWNERO_TransactionInfo_direction');
+  return tiDir;
+}
+
+bool TransactionInfo_isPending(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_isPending');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isPending = lib!.WOWNERO_TransactionInfo_isPending(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_isPending');
+
+  return isPending;
+}
+
+bool TransactionInfo_isFailed(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_isFailed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isFailed = lib!.WOWNERO_TransactionInfo_isFailed(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_isFailed');
+  return isFailed;
+}
+
+bool TransactionInfo_isCoinbase(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_isCoinbase');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isCoinbase = lib!.WOWNERO_TransactionInfo_isCoinbase(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_isCoinbase');
+  return isCoinbase;
+}
+
+int TransactionInfo_amount(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final amount = lib!.WOWNERO_TransactionInfo_amount(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_amount');
+  return amount;
+}
+
+int TransactionInfo_fee(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_fee');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final fee = lib!.WOWNERO_TransactionInfo_fee(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_fee');
+  return fee;
+}
+
+int TransactionInfo_blockHeight(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_blockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final blockHeight = lib!.WOWNERO_TransactionInfo_blockHeight(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_blockHeight');
+  return blockHeight;
+}
+
+String TransactionInfo_description(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_description');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_description(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_description');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_description', e);
+    return "";
+  }
+}
+
+String TransactionInfo_subaddrIndex(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_subaddrIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_TransactionInfo_subaddrIndex(ptr, defaultSeparator)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_subaddrIndex');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_subaddrIndex', e);
+    return "";
+  }
+}
+
+int TransactionInfo_subaddrAccount(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_subaddrAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final subaddrAccount = lib!.WOWNERO_TransactionInfo_subaddrAccount(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_subaddrAccount');
+  return subaddrAccount;
+}
+
+String TransactionInfo_label(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_label');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_label(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_label');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_label', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_label');
+    return "";
+  }
+}
+
+int TransactionInfo_confirmations(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_confirmations');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final confirmations = lib!.WOWNERO_TransactionInfo_confirmations(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_confirmations');
+  return confirmations;
+}
+
+int TransactionInfo_unlockTime(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_unlockTime');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final unlockTime = lib!.WOWNERO_TransactionInfo_unlockTime(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_unlockTime');
+  return unlockTime;
+}
+
+String TransactionInfo_hash(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_hash');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_hash(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_hash');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_hash', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_hash');
+    return "";
+  }
+}
+
+int TransactionInfo_timestamp(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_timestamp');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final timestamp = lib!.WOWNERO_TransactionInfo_timestamp(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_timestamp');
+  return timestamp;
+}
+
+String TransactionInfo_paymentId(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_paymentId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_paymentId(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_paymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_paymentId', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_paymentId');
+    return "";
+  }
+}
+
+int TransactionInfo_transfers_count(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_transfers_count');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_TransactionInfo_transfers_count(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_transfers_count');
+  return v;
+}
+
+int TransactionInfo_transfers_amount(TransactionInfo ptr, int index) {
+  debugStart?.call('WOWNERO_TransactionInfo_transfers_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_TransactionInfo_transfers_amount(ptr, index);
+  debugEnd?.call('WOWNERO_TransactionInfo_transfers_amount');
+  return v;
+}
+
+String TransactionInfo_transfers_address(TransactionInfo ptr, int index) {
+  debugStart?.call('WOWNERO_TransactionInfo_transfers_address');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_TransactionInfo_transfers_address(ptr, index).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_transfers_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_transfers_address', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_transfers_address');
+    return "";
+  }
+}
+
+// TransactionHistory
+
+typedef TransactionHistory = Pointer<Void>;
+
+int TransactionHistory_count(TransactionHistory txHistory_ptr) {
+  debugStart?.call('WOWNERO_TransactionHistory_count');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final count = lib!.WOWNERO_TransactionHistory_count(txHistory_ptr);
+  debugEnd?.call('WOWNERO_TransactionHistory_count');
+  return count;
+}
+
+TransactionInfo TransactionHistory_transaction(TransactionHistory txHistory_ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_TransactionHistory_transaction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final transaction =
+      lib!.WOWNERO_TransactionHistory_transaction(txHistory_ptr, index);
+  debugEnd?.call('WOWNERO_TransactionHistory_transaction');
+  return transaction;
+}
+
+TransactionInfo TransactionHistory_transactionById(
+    TransactionHistory txHistory_ptr,
+    {required String txid}) {
+  debugStart?.call('WOWNERO_TransactionHistory_transactionById');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final transaction =
+      lib!.WOWNERO_TransactionHistory_transactionById(txHistory_ptr, txid_);
+  calloc.free(txid_);
+  debugEnd?.call('WOWNERO_TransactionHistory_transactionById');
+  return transaction;
+}
+
+void TransactionHistory_refresh(TransactionHistory txHistory_ptr) {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  return lib!.WOWNERO_TransactionHistory_refresh(txHistory_ptr);
+}
+
+void TransactionHistory_setTxNote(TransactionHistory txHistory_ptr,
+    {required String txid, required String note}) {
+  debugStart?.call('WOWNERO_TransactionHistory_setTxNote');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final note_ = note.toNativeUtf8().cast<Char>();
+  final s =
+      lib!.WOWNERO_TransactionHistory_setTxNote(txHistory_ptr, txid_, note_);
+  calloc.free(txid_);
+  calloc.free(note_);
+  debugEnd?.call('WOWNERO_TransactionHistory_setTxNote');
+  return s;
+}
+
+// AddresBookRow
+
+typedef AddressBookRow = Pointer<Void>;
+
+String AddressBookRow_extra(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_extra');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_AddressBookRow_extra(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_extra', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_extra');
+    return "";
+  }
+}
+
+String AddressBookRow_getAddress(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_AddressBookRow_getAddress(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_getAddress', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_getAddress');
+    return "";
+  }
+}
+
+String AddressBookRow_getDescription(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getDescription');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_AddressBookRow_getDescription(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_getDescription');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_getDescription', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_getDescription');
+    return "";
+  }
+}
+
+String AddressBookRow_getPaymentId(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getPaymentId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_AddressBookRow_getPaymentId(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_getPaymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_getPaymentId', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_getPaymentId');
+    return "";
+  }
+}
+
+int AddressBookRow_getRowId(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getRowId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBookRow_getRowId(addressBookRow_ptr);
+  debugEnd?.call('WOWNERO_AddressBookRow_getRowId');
+  return v;
+}
+
+// AddressBook
+
+typedef AddressBook = Pointer<Void>;
+
+int AddressBook_getAll_size(AddressBook addressBook_ptr) {
+  debugStart?.call('WOWNERO_AddressBook_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_getAll_size(addressBook_ptr);
+  debugEnd?.call('WOWNERO_AddressBook_getAll_size');
+  return v;
+}
+
+AddressBookRow AddressBook_getAll_byIndex(AddressBook addressBook_ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_AddressBook_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_getAll_byIndex(addressBook_ptr, index);
+  debugEnd?.call('WOWNERO_AddressBook_getAll_byIndex');
+  return v;
+}
+
+bool AddressBook_addRow(
+  AddressBook addressBook_ptr, {
+  required String dstAddr,
+  required String paymentId,
+  required String description,
+}) {
+  debugStart?.call('WOWNERO_AddressBook_addRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dst_addr_ = dstAddr.toNativeUtf8().cast<Char>();
+  final payment_id_ = paymentId.toNativeUtf8().cast<Char>();
+  final description_ = description.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_AddressBook_addRow(
+      addressBook_ptr, dst_addr_, payment_id_, description_);
+  calloc.free(dst_addr_);
+  calloc.free(payment_id_);
+  calloc.free(description_);
+  debugEnd?.call('WOWNERO_AddressBook_addRow');
+  return v;
+}
+
+bool AddressBook_deleteRow(AddressBook addressBook_ptr, {required int rowId}) {
+  debugStart?.call('WOWNERO_AddressBook_deleteRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_deleteRow(addressBook_ptr, rowId);
+  debugEnd?.call('WOWNERO_AddressBook_deleteRow');
+  return v;
+}
+
+bool AddressBook_setDescription(
+  AddressBook addressBook_ptr, {
+  required int rowId,
+  required String description,
+}) {
+  debugStart?.call('WOWNERO_AddressBook_setDescription');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final description_ = description.toNativeUtf8().cast<Char>();
+  final v = lib!
+      .WOWNERO_AddressBook_setDescription(addressBook_ptr, rowId, description_);
+  calloc.free(description_);
+  debugEnd?.call('WOWNERO_AddressBook_setDescription');
+  return v;
+}
+
+void AddressBook_refresh(AddressBook addressBook_ptr) {
+  debugStart?.call('WOWNERO_AddressBook_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_refresh(addressBook_ptr);
+  debugEnd?.call('WOWNERO_AddressBook_refresh');
+  return v;
+}
+
+int AddressBook_errorCode(AddressBook addressBook_ptr) {
+  debugStart?.call('WOWNERO_AddressBook_errorCode');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_errorCode(addressBook_ptr);
+  debugEnd?.call('WOWNERO_AddressBook_errorCode');
+  return v;
+}
+
+int AddressBook_lookupPaymentID(AddressBook addressBook_ptr,
+    {required String paymentId}) {
+  debugStart?.call('WOWNERO_AddressBook_lookupPaymentID');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+  final v =
+      lib!.WOWNERO_AddressBook_lookupPaymentID(addressBook_ptr, paymentId_);
+  calloc.free(paymentId_);
+  debugEnd?.call('WOWNERO_AddressBook_lookupPaymentID');
+  return v;
+}
+
+// CoinsInfo
+typedef CoinsInfo = Pointer<Void>;
+
+int CoinsInfo_blockHeight(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_blockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_blockHeight(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_blockHeight');
+  return v;
+}
+
+String CoinsInfo_hash(CoinsInfo addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_hash');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_CoinsInfo_hash(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_hash');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_hash', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_hash');
+    return "";
+  }
+}
+
+int CoinsInfo_internalOutputIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_internalOutputIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_internalOutputIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_internalOutputIndex');
+  return v;
+}
+
+int CoinsInfo_globalOutputIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_globalOutputIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_globalOutputIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_globalOutputIndex');
+  return v;
+}
+
+bool CoinsInfo_spent(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_spent');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_spent(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_spent');
+  return v;
+}
+
+bool CoinsInfo_frozen(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_frozen');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_frozen(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_frozen');
+  return v;
+}
+
+int CoinsInfo_spentHeight(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_spentHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_spentHeight(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_spentHeight');
+  return v;
+}
+
+int CoinsInfo_amount(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_amount(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_amount');
+  return v;
+}
+
+bool CoinsInfo_rct(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_rct');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_rct(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_rct');
+  return v;
+}
+
+bool CoinsInfo_keyImageKnown(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_keyImageKnown');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_keyImageKnown(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_keyImageKnown');
+  return v;
+}
+
+int CoinsInfo_pkIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_pkIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_pkIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_pkIndex');
+  return v;
+}
+
+int CoinsInfo_subaddrIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_subaddrIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_subaddrIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_subaddrIndex');
+  return v;
+}
+
+int CoinsInfo_subaddrAccount(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_subaddrAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_subaddrAccount(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_subaddrAccount');
+  return v;
+}
+
+String CoinsInfo_address(CoinsInfo addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_address');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_CoinsInfo_address(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_address', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_address');
+    return "";
+  }
+}
+
+String CoinsInfo_addressLabel(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_addressLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_CoinsInfo_addressLabel(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_addressLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_addressLabel', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_addressLabel');
+    return "";
+  }
+}
+
+String CoinsInfo_keyImage(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_keyImage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_CoinsInfo_keyImage(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_keyImage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_keyImage', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_keyImage');
+    return "";
+  }
+}
+
+int CoinsInfo_unlockTime(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_unlockTime');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_unlockTime(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_unlockTime');
+  return v;
+}
+
+bool CoinsInfo_unlocked(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_unlocked');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_unlocked(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_unlocked');
+  return v;
+}
+
+String CoinsInfo_pubKey(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_pubKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_CoinsInfo_pubKey(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_pubKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_pubKey', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_pubKey');
+    return "";
+  }
+}
+
+bool CoinsInfo_coinbase(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_coinbase');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_coinbase(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_coinbase');
+  return v;
+}
+
+String CoinsInfo_description(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_description');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_CoinsInfo_description(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_description');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_description', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_description');
+    return "";
+  }
+}
+
+typedef Coins = Pointer<Void>;
+
+int Coins_count(Coins coins_ptr) {
+  debugStart?.call('WOWNERO_Coins_count');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_count(coins_ptr);
+  debugEnd?.call('WOWNERO_Coins_count');
+  return v;
+}
+
+CoinsInfo Coins_coin(Coins coins_ptr, int index) {
+  debugStart?.call('WOWNERO_Coins_coin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_coin(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_coin');
+  return v;
+}
+
+int Coins_getAll_size(Coins coins_ptr) {
+  debugStart?.call('WOWNERO_Coins_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_getAll_size(coins_ptr);
+  debugEnd?.call('WOWNERO_Coins_getAll_size');
+  return v;
+}
+
+CoinsInfo Coins_getAll_byIndex(Coins coins_ptr, int index) {
+  debugStart?.call('WOWNERO_Coins_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_getAll_byIndex(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_getAll_byIndex');
+  return v;
+}
+
+void Coins_refresh(Coins coins_ptr) {
+  debugStart?.call('WOWNERO_Coins_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_refresh(coins_ptr);
+  debugEnd?.call('WOWNERO_Coins_refresh');
+  return v;
+}
+
+void Coins_setFrozenByPublicKey(Coins coins_ptr, {required String publicKey}) {
+  debugStart?.call('WOWNERO_Coins_setFrozenByPublicKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final publicKey_ = publicKey.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Coins_setFrozenByPublicKey(coins_ptr, publicKey_);
+  calloc.free(publicKey_);
+  debugEnd?.call('WOWNERO_Coins_setFrozenByPublicKey');
+  return v;
+}
+
+void Coins_setFrozen(Coins coins_ptr, {required int index}) {
+  debugStart?.call('WOWNERO_Coins_setFrozen');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_setFrozen(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_setFrozen');
+  return v;
+}
+
+void Coins_thaw(Coins coins_ptr, {required int index}) {
+  debugStart?.call('WOWNERO_Coins_thaw');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_thaw(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_thaw');
+  return v;
+}
+
+void Coins_thawByPublicKey(Coins coins_ptr, {required String publicKey}) {
+  debugStart?.call('WOWNERO_Coins_thawByPublicKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final publicKey_ = publicKey.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Coins_thawByPublicKey(coins_ptr, publicKey_);
+  calloc.free(publicKey_);
+  debugEnd?.call('WOWNERO_Coins_thawByPublicKey');
+  return v;
+}
+
+bool Coins_isTransferUnlocked(
+  Coins coins_ptr, {
+  required int unlockTime,
+  required int blockHeight,
+}) {
+  debugStart?.call('WOWNERO_Coins_isTransferUnlocked');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v =
+      lib!.WOWNERO_Coins_isTransferUnlocked(coins_ptr, unlockTime, blockHeight);
+  debugEnd?.call('WOWNERO_Coins_isTransferUnlocked');
+  return v;
+}
+
+// SubaddressRow
+
+typedef SubaddressRow = Pointer<Void>;
+
+String SubaddressRow_extra(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_extra');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_SubaddressRow_extra(subaddressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressRow_extra', e);
+    debugEnd?.call('WOWNERO_SubaddressRow_extra');
+    return "";
+  }
+}
+
+String SubaddressRow_getAddress(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_getAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressRow_getAddress(subaddressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressRow_getAddress', e);
+    debugEnd?.call('WOWNERO_SubaddressRow_getAddress');
+    return "";
+  }
+}
+
+String SubaddressRow_getLabel(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_getLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_SubaddressRow_getLabel(subaddressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressRow_getLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressRow_getLabel', e);
+    debugEnd?.call('WOWNERO_SubaddressRow_getLabel');
+    return "";
+  }
+}
+
+int SubaddressRow_getRowId(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_getRowId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressRow_getRowId(subaddressBookRow_ptr);
+  debugEnd?.call('WOWNERO_SubaddressRow_getRowId');
+  return status;
+}
+
+// Subaddress
+
+typedef Subaddress = Pointer<Void>;
+
+int Subaddress_getAll_size(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_Subaddress_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Subaddress_getAll_size(subaddressBookRow_ptr);
+  debugEnd?.call('WOWNERO_Subaddress_getAll_size');
+  return status;
+}
+
+SubaddressRow Subaddress_getAll_byIndex(Subaddress subaddressRow_ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_Subaddress_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.WOWNERO_Subaddress_getAll_byIndex(subaddressRow_ptr, index);
+  debugEnd?.call('WOWNERO_Subaddress_getAll_byIndex');
+  return status;
+}
+
+void Subaddress_addRow(Subaddress ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('WOWNERO_Subaddress_addRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Subaddress_addRow(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Subaddress_addRow');
+  return status;
+}
+
+void Subaddress_setLabel(Subaddress ptr,
+    {required int accountIndex,
+    required int addressIndex,
+    required String label}) {
+  debugStart?.call('WOWNERO_Subaddress_setLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status =
+      lib!.WOWNERO_Subaddress_setLabel(ptr, accountIndex, addressIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Subaddress_setLabel');
+  return status;
+}
+
+void Subaddress_refresh(Subaddress ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('WOWNERO_Subaddress_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Subaddress_refresh(ptr, accountIndex);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Subaddress_refresh');
+  return status;
+}
+
+typedef SubaddressAccountRow = Pointer<Void>;
+
+String SubaddressAccountRow_extra(SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_extra');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_extra(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_extra', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_extra');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getAddress(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getAddress(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getAddress', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getAddress');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getLabel(SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getLabel(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getLabel', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getLabel');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getBalance(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getBalance(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getBalance');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getBalance', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getBalance');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getUnlockedBalance(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getUnlockedBalance(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+    return "";
+  }
+}
+
+int SubaddressAccountRow_getRowId(SubaddressAccountRow ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getRowId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccountRow_getRowId(ptr);
+  debugEnd?.call('WOWNERO_SubaddressAccountRow_getRowId');
+  return status;
+}
+
+typedef SubaddressAccount = Pointer<Void>;
+
+int SubaddressAccount_getAll_size(SubaddressAccount ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccount_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccount_getAll_size(ptr);
+  debugEnd?.call('WOWNERO_SubaddressAccount_getAll_size');
+  return status;
+}
+
+SubaddressAccountRow SubaddressAccount_getAll_byIndex(SubaddressAccount ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_SubaddressAccount_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccount_getAll_byIndex(ptr, index);
+  debugEnd?.call('WOWNERO_SubaddressAccount_getAll_byIndex');
+  return status;
+}
+
+void SubaddressAccount_addRow(SubaddressAccount ptr, {required String label}) {
+  debugStart?.call('WOWNERO_SubaddressAccount_addRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_SubaddressAccount_addRow(ptr, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_SubaddressAccount_addRow');
+  return status;
+}
+
+void SubaddressAccount_setLabel(SubaddressAccount ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('WOWNERO_SubaddressAccount_setLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status =
+      lib!.WOWNERO_SubaddressAccount_setLabel(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_SubaddressAccount_setLabel');
+  return status;
+}
+
+void SubaddressAccount_refresh(SubaddressAccount ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccount_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccount_refresh(ptr);
+  debugEnd?.call('WOWNERO_SubaddressAccount_refresh');
+  return status;
+}
+
+// MultisigState
+
+typedef MultisigState = Pointer<Void>;
+
+bool MultisigState_isMultisig(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_isMultisig');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_isMultisig(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_isMultisig');
+  return status;
+}
+
+bool MultisigState_isReady(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_isReady');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_isReady(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_isReady');
+  return status;
+}
+
+int MultisigState_threshold(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_threshold');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_threshold(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_threshold');
+  return status;
+}
+
+int MultisigState_total(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_total');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_total(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_total');
+  return status;
+}
+
+// DeviceProgress
+
+typedef DeviceProgress = Pointer<Void>;
+
+bool DeviceProgress_progress(DeviceProgress ptr) {
+  debugStart?.call('WOWNERO_DeviceProgress_progress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_DeviceProgress_progress(ptr);
+  debugEnd?.call('WOWNERO_DeviceProgress_progress');
+  return status;
+}
+
+bool DeviceProgress_indeterminate(DeviceProgress ptr) {
+  debugStart?.call('WOWNERO_DeviceProgress_indeterminate');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_DeviceProgress_indeterminate(ptr);
+  debugEnd?.call('WOWNERO_DeviceProgress_indeterminate');
+  return status;
+}
+// Wallet
+
+typedef wallet = Pointer<Void>;
+
+String Wallet_seed(wallet ptr, {required String seedOffset}) {
+  debugStart?.call('WOWNERO_Wallet_seed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.WOWNERO_Wallet_seed(ptr, seedOffset_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(seedOffset_);
+    debugEnd?.call('WOWNERO_Wallet_seed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_seed', e);
+    debugEnd?.call('WOWNERO_Wallet_seed');
+    return "";
+  }
+}
+
+String Wallet_getSeedLanguage(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getSeedLanguage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_getSeedLanguage(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getSeedLanguage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getSeedLanguage', e);
+    debugEnd?.call('WOWNERO_Wallet_getSeedLanguage');
+    return "";
+  }
+}
+
+void Wallet_setSeedLanguage(wallet ptr, {required String language}) {
+  debugStart?.call('WOWNERO_Wallet_setSeedLanguage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Wallet_setSeedLanguage(ptr, language_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_Wallet_setSeedLanguage');
+  return status;
+}
+
+int Wallet_status(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_status');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_status(ptr);
+  debugEnd?.call('WOWNERO_Wallet_status');
+  return status;
+}
+
+String Wallet_errorString(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_errorString');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_errorString(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_errorString', e);
+    debugEnd?.call('WOWNERO_Wallet_errorString');
+    return "";
+  }
+}
+
+bool Wallet_setPassword(wallet ptr, {required String password}) {
+  debugStart?.call('WOWNERO_Wallet_setPassword');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Wallet_setPassword(ptr, password_);
+  calloc.free(password_);
+  debugEnd?.call('WOWNERO_Wallet_setPassword');
+  return status;
+}
+
+String Wallet_getPassword(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getPassword');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_getPassword(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getPassword');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getPassword', e);
+    debugEnd?.call('WOWNERO_Wallet_getPassword');
+    return "";
+  }
+}
+
+bool Wallet_setDevicePin(wallet ptr, {required String passphrase}) {
+  debugStart?.call('WOWNERO_Wallet_setDevicePin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final passphrase_ = passphrase.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Wallet_setDevicePin(ptr, passphrase_);
+  calloc.free(passphrase_);
+  debugEnd?.call('WOWNERO_Wallet_setDevicePin');
+  return status;
+}
+
+String Wallet_address(wallet ptr,
+    {int accountIndex = 0, int addressIndex = 0}) {
+  debugStart?.call('WOWNERO_Wallet_address');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_Wallet_address(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_address', e);
+    debugEnd?.call('WOWNERO_Wallet_address');
+    return "";
+  }
+}
+
+String Wallet_path(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_path');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_path(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_path');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_path', e);
+    debugEnd?.call('WOWNERO_Wallet_path');
+    return "";
+  }
+}
+
+int Wallet_nettype(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_nettype');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_nettype(ptr);
+  debugEnd?.call('WOWNERO_Wallet_nettype');
+  return status;
+}
+
+int Wallet_useForkRules(
+  wallet ptr, {
+  required int version,
+  required int earlyBlocks,
+}) {
+  debugStart?.call('WOWNERO_Wallet_useForkRules');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_useForkRules(ptr, version, earlyBlocks);
+  debugEnd?.call('WOWNERO_Wallet_useForkRules');
+  return status;
+}
+
+String Wallet_integratedAddress(wallet ptr, {required String paymentId}) {
+  debugStart?.call('WOWNERO_Wallet_integratedAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_integratedAddress(ptr, paymentId_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_integratedAddress');
+    calloc.free(paymentId_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_integratedAddress', e);
+    debugEnd?.call('WOWNERO_Wallet_integratedAddress');
+    return "";
+  }
+}
+
+String Wallet_secretViewKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_secretViewKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_secretViewKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_secretViewKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_secretViewKey', e);
+    debugEnd?.call('WOWNERO_Wallet_secretViewKey');
+    return "";
+  }
+}
+
+String Wallet_publicViewKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_publicViewKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_publicViewKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_publicViewKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_publicViewKey', e);
+    debugEnd?.call('WOWNERO_Wallet_publicViewKey');
+    return "";
+  }
+}
+
+String Wallet_secretSpendKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_secretSpendKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_secretSpendKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_secretSpendKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_secretSpendKey', e);
+    debugEnd?.call('WOWNERO_Wallet_secretSpendKey');
+    return "";
+  }
+}
+
+String Wallet_publicSpendKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_publicSpendKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_publicSpendKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_publicSpendKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_publicSpendKey', e);
+    debugEnd?.call('WOWNERO_Wallet_publicSpendKey');
+    return "";
+  }
+}
+
+String Wallet_publicMultisigSignerKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_publicMultisigSignerKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_Wallet_publicMultisigSignerKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_publicMultisigSignerKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_publicMultisigSignerKey', e);
+    debugEnd?.call('WOWNERO_Wallet_publicMultisigSignerKey');
+    return "";
+  }
+}
+
+void Wallet_stop(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_stop');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final stop = lib!.WOWNERO_Wallet_stop(ptr);
+  debugEnd?.call('WOWNERO_Wallet_stop');
+  return stop;
+}
+
+bool Wallet_store(wallet ptr, {String path = ""}) {
+  debugStart?.call('WOWNERO_Wallet_store');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_store(ptr, path_);
+  calloc.free(path_);
+  debugEnd?.call('WOWNERO_Wallet_store');
+  return s;
+}
+
+String Wallet_filename(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_filename');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_filename(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_filename');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_filename', e);
+    debugEnd?.call('WOWNERO_Wallet_filename');
+    return "";
+  }
+}
+
+String Wallet_keysFilename(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_keysFilename');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_keysFilename(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_keysFilename');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_keysFilename', e);
+    debugEnd?.call('WOWNERO_Wallet_keysFilename');
+    return "";
+  }
+}
+
+bool Wallet_init(
+  wallet ptr, {
+  required String daemonAddress,
+  int upperTransacationSizeLimit = 0,
+  String daemonUsername = "",
+  String daemonPassword = "",
+  bool useSsl = false,
+  bool lightWallet = false,
+  String proxyAddress = "",
+}) {
+  debugStart?.call('WOWNERO_Wallet_init');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final daemonAddress_ = daemonAddress.toNativeUtf8().cast<Char>();
+  final daemonUsername_ = daemonUsername.toNativeUtf8().cast<Char>();
+  final daemonPassword_ = daemonPassword.toNativeUtf8().cast<Char>();
+  final proxyAddress_ = proxyAddress.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_init(
+      ptr,
+      daemonAddress_,
+      upperTransacationSizeLimit,
+      daemonUsername_,
+      daemonPassword_,
+      useSsl,
+      lightWallet,
+      proxyAddress_);
+
+  calloc.free(daemonAddress_);
+  calloc.free(daemonUsername_);
+  calloc.free(daemonPassword_);
+  calloc.free(proxyAddress_);
+  debugEnd?.call('WOWNERO_Wallet_init');
+  return s;
+}
+
+bool Wallet_createWatchOnly(
+  wallet ptr, {
+  required String path,
+  required String password,
+  required String language,
+}) {
+  debugStart?.call('WOWNERO_Wallet_createWatchOnly');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final getRefreshFromBlockHeight =
+      lib!.WOWNERO_Wallet_createWatchOnly(ptr, path_, password_, language_);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_Wallet_createWatchOnly');
+  return getRefreshFromBlockHeight;
+}
+
+void Wallet_setRefreshFromBlockHeight(wallet ptr,
+    {required int refresh_from_block_height}) {
+  debugStart?.call('WOWNERO_Wallet_setRefreshFromBlockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!
+      .WOWNERO_Wallet_setRefreshFromBlockHeight(ptr, refresh_from_block_height);
+  debugEnd?.call('WOWNERO_Wallet_setRefreshFromBlockHeight');
+  return status;
+}
+
+int Wallet_getRefreshFromBlockHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getRefreshFromBlockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final getRefreshFromBlockHeight =
+      lib!.WOWNERO_Wallet_getRefreshFromBlockHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getRefreshFromBlockHeight');
+  return getRefreshFromBlockHeight;
+}
+
+void Wallet_setRecoveringFromSeed(wallet ptr,
+    {required bool recoveringFromSeed}) {
+  debugStart?.call('WOWNERO_Wallet_setRecoveringFromSeed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.WOWNERO_Wallet_setRecoveringFromSeed(ptr, recoveringFromSeed);
+  debugEnd?.call('WOWNERO_Wallet_setRecoveringFromSeed');
+  return status;
+}
+
+void Wallet_setRecoveringFromDevice(wallet ptr,
+    {required bool recoveringFromDevice}) {
+  debugStart?.call('WOWNERO_Wallet_setRecoveringFromDevice');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.WOWNERO_Wallet_setRecoveringFromDevice(ptr, recoveringFromDevice);
+  debugEnd?.call('WOWNERO_Wallet_setRecoveringFromDevice');
+  return status;
+}
+
+void Wallet_setSubaddressLookahead(wallet ptr,
+    {required int major, required int minor}) {
+  debugStart?.call('WOWNERO_Wallet_setSubaddressLookahead');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_setSubaddressLookahead(ptr, major, minor);
+  debugEnd?.call('WOWNERO_Wallet_setSubaddressLookahead');
+  return status;
+}
+
+bool Wallet_connectToDaemon(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_connectToDaemon');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final connectToDaemon = lib!.WOWNERO_Wallet_connectToDaemon(ptr);
+  debugEnd?.call('WOWNERO_Wallet_connectToDaemon');
+  return connectToDaemon;
+}
+
+int Wallet_connected(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_connected');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final connected = lib!.WOWNERO_Wallet_connected(ptr);
+  debugEnd?.call('WOWNERO_Wallet_connected');
+  return connected;
+}
+
+void Wallet_setTrustedDaemon(wallet ptr, {required bool arg}) {
+  debugStart?.call('WOWNERO_Wallet_setTrustedDaemon');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_setTrustedDaemon(ptr, arg);
+  debugEnd?.call('WOWNERO_Wallet_setTrustedDaemon');
+  return status;
+}
+
+bool Wallet_trustedDaemon(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_trustedDaemon');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_trustedDaemon(ptr);
+  debugEnd?.call('WOWNERO_Wallet_trustedDaemon');
+  return status;
+}
+
+bool Wallet_setProxy(wallet ptr, {required String address}) {
+  debugStart?.call('WOWNERO_Wallet_setProxy');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_setProxy(ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_Wallet_setProxy');
+  return s;
+}
+
+int Wallet_balance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_balance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final balance = lib!.WOWNERO_Wallet_balance(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_balance');
+  return balance;
+}
+
+int Wallet_unlockedBalance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_unlockedBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final unlockedBalance =
+      lib!.WOWNERO_Wallet_unlockedBalance(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_unlockedBalance');
+  return unlockedBalance;
+}
+
+int Wallet_viewOnlyBalance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_viewOnlyBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final unlockedBalance =
+      lib!.WOWNERO_Wallet_viewOnlyBalance(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_viewOnlyBalance');
+  return unlockedBalance;
+}
+
+bool Wallet_watchOnly(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_watchOnly');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final watchOnly = lib!.WOWNERO_Wallet_watchOnly(ptr);
+  debugEnd?.call('WOWNERO_Wallet_watchOnly');
+  return watchOnly;
+}
+
+int Wallet_blockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_blockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final blockChainHeight = lib!.WOWNERO_Wallet_blockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_blockChainHeight');
+  return blockChainHeight;
+}
+
+int Wallet_approximateBlockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_approximateBlockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final approximateBlockChainHeight =
+      lib!.WOWNERO_Wallet_approximateBlockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_approximateBlockChainHeight');
+  return approximateBlockChainHeight;
+}
+
+int Wallet_estimateBlockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_estimateBlockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final estimateBlockChainHeight =
+      lib!.WOWNERO_Wallet_estimateBlockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_estimateBlockChainHeight');
+  return estimateBlockChainHeight;
+}
+
+int Wallet_daemonBlockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_daemonBlockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final daemonBlockChainHeight =
+      lib!.WOWNERO_Wallet_daemonBlockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_daemonBlockChainHeight');
+  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));
+  final synchronized = lib!.WOWNERO_Wallet_synchronized(ptr);
+  debugEnd?.call('WOWNERO_Wallet_synchronized');
+  return synchronized;
+}
+
+String Wallet_displayAmount(int amount) {
+  debugStart?.call('WOWNERO_Wallet_displayAmount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_displayAmount(amount).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_displayAmount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_displayAmount', e);
+    debugEnd?.call('WOWNERO_Wallet_displayAmount');
+    return "";
+  }
+}
+
+int Wallet_amountFromString(String amount) {
+  debugStart?.call('WOWNERO_Wallet_amountFromString');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final amount_ = amount.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_amountFromString(amount_);
+  calloc.free(amount_);
+  debugEnd?.call('WOWNERO_Wallet_amountFromString');
+  return s;
+}
+
+int Wallet_amountFromDouble(double amount) {
+  debugStart?.call('WOWNERO_Wallet_amountFromDouble');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_Wallet_amountFromDouble(amount);
+  debugEnd?.call('WOWNERO_Wallet_amountFromDouble');
+  return s;
+}
+
+String Wallet_genPaymentId() {
+  debugStart?.call('WOWNERO_Wallet_genPaymentId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_genPaymentId().cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_genPaymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_genPaymentId', e);
+    debugEnd?.call('WOWNERO_Wallet_genPaymentId');
+    return "";
+  }
+}
+
+bool Wallet_paymentIdValid(String paymentId) {
+  debugStart?.call('WOWNERO_Wallet_paymentIdValid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_paymentIdValid(paymentId_);
+  calloc.free(paymentId_);
+  debugEnd?.call('WOWNERO_Wallet_paymentIdValid');
+  return s;
+}
+
+bool Wallet_addressValid(String address, int networkType) {
+  debugStart?.call('WOWNERO_Wallet_addressValid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_addressValid(address_, networkType);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_Wallet_addressValid');
+  return s;
+}
+
+bool Wallet_keyValid(
+    {required String secret_key_string,
+    required String address_string,
+    required bool isViewKey,
+    required int nettype}) {
+  debugStart?.call('WOWNERO_Wallet_keyValid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final secret_key_string_ = secret_key_string.toNativeUtf8().cast<Char>();
+  final address_string_ = address_string.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_keyValid(
+      secret_key_string_, address_string_, isViewKey, nettype);
+  calloc.free(secret_key_string_);
+  calloc.free(address_string_);
+  debugEnd?.call('WOWNERO_Wallet_keyValid');
+  return s;
+}
+
+String Wallet_keyValid_error(
+    {required String secret_key_string,
+    required String address_string,
+    required bool isViewKey,
+    required int nettype}) {
+  debugStart?.call('WOWNERO_Wallet_keyValid_error');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final secret_key_string_ = secret_key_string.toNativeUtf8().cast<Char>();
+    final address_string_ = address_string.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .WOWNERO_Wallet_keyValid_error(
+            secret_key_string_, address_string_, isViewKey, nettype)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(secret_key_string_);
+    calloc.free(address_string_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_keyValid_error', e);
+    debugEnd?.call('WOWNERO_Wallet_keyValid_error');
+    return "";
+  }
+}
+
+String Wallet_paymentIdFromAddress(
+    {required String strarg, required int nettype}) {
+  debugStart?.call('WOWNERO_Wallet_paymentIdFromAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strarg_ = strarg.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_paymentIdFromAddress(strarg_, nettype).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(strarg_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_paymentIdFromAddress', e);
+    debugEnd?.call('WOWNERO_Wallet_paymentIdFromAddress');
+    return "";
+  }
+}
+
+int Wallet_maximumAllowedAmount() {
+  debugStart?.call('WOWNERO_Wallet_maximumAllowedAmount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_Wallet_maximumAllowedAmount();
+  debugEnd?.call('WOWNERO_Wallet_maximumAllowedAmount');
+  return s;
+}
+
+void Wallet_init3(
+  wallet ptr, {
+  required String argv0,
+  required String defaultLogBaseName,
+  required String logPath,
+  required bool console,
+}) {
+  debugStart?.call('WOWNERO_Wallet_init3');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final argv0_ = argv0.toNativeUtf8().cast<Char>();
+  final defaultLogBaseName_ = defaultLogBaseName.toNativeUtf8().cast<Char>();
+  final logPath_ = logPath.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_init3(
+      ptr, argv0_, defaultLogBaseName_, logPath_, console);
+  calloc.free(argv0_);
+  calloc.free(defaultLogBaseName_);
+  calloc.free(logPath_);
+  debugEnd?.call('WOWNERO_Wallet_init3');
+  return s;
+}
+
+String Wallet_getPolyseed(wallet ptr, {required String passphrase}) {
+  debugStart?.call('WOWNERO_Wallet_getPolyseed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final passphrase_ = passphrase.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_getPolyseed(ptr, passphrase_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(passphrase_);
+    debugEnd?.call('WOWNERO_Wallet_getPolyseed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getPolyseed', e);
+    debugEnd?.call('WOWNERO_Wallet_getPolyseed');
+    return "";
+  }
+}
+
+String Wallet_createPolyseed({
+  String language = "English",
+}) {
+  debugStart?.call('WOWNERO_Wallet_createPolyseed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final language_ = language.toNativeUtf8();
+    final strPtr =
+        lib!.WOWNERO_Wallet_createPolyseed(language_.cast()).cast<Utf8>();
+    calloc.free(language_);
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_createPolyseed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_createPolyseed', e);
+    debugEnd?.call('WOWNERO_Wallet_createPolyseed');
+    return "";
+  }
+}
+
+void Wallet_startRefresh(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_startRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final startRefresh = lib!.WOWNERO_Wallet_startRefresh(ptr);
+  debugEnd?.call('WOWNERO_Wallet_startRefresh');
+  return startRefresh;
+}
+
+void Wallet_pauseRefresh(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_pauseRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final pauseRefresh = lib!.WOWNERO_Wallet_pauseRefresh(ptr);
+  debugEnd?.call('WOWNERO_Wallet_pauseRefresh');
+  return pauseRefresh;
+}
+
+bool Wallet_refresh(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final refresh = lib!.WOWNERO_Wallet_refresh(ptr);
+  debugEnd?.call('WOWNERO_Wallet_refresh');
+  return refresh;
+}
+
+void Wallet_refreshAsync(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_refreshAsync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final refreshAsync = lib!.WOWNERO_Wallet_refreshAsync(ptr);
+  debugEnd?.call('WOWNERO_Wallet_refreshAsync');
+  return refreshAsync;
+}
+
+bool Wallet_rescanBlockchain(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_rescanBlockchain');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final rescanBlockchain = lib!.WOWNERO_Wallet_rescanBlockchain(ptr);
+  debugEnd?.call('WOWNERO_Wallet_rescanBlockchain');
+  return rescanBlockchain;
+}
+
+void Wallet_rescanBlockchainAsync(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_rescanBlockchainAsync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final rescanBlockchainAsync = lib!.WOWNERO_Wallet_rescanBlockchainAsync(ptr);
+  debugEnd?.call('WOWNERO_Wallet_rescanBlockchainAsync');
+  return rescanBlockchainAsync;
+}
+
+void Wallet_setAutoRefreshInterval(wallet ptr, {required int millis}) {
+  debugStart?.call('WOWNERO_Wallet_setAutoRefreshInterval');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final setAutoRefreshInterval =
+      lib!.WOWNERO_Wallet_setAutoRefreshInterval(ptr, millis);
+  debugEnd?.call('WOWNERO_Wallet_setAutoRefreshInterval');
+  return setAutoRefreshInterval;
+}
+
+int Wallet_autoRefreshInterval(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_autoRefreshInterval');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final autoRefreshInterval = lib!.WOWNERO_Wallet_autoRefreshInterval(ptr);
+  debugEnd?.call('WOWNERO_Wallet_autoRefreshInterval');
+  return autoRefreshInterval;
+}
+
+void Wallet_addSubaddress(wallet ptr,
+    {required int accountIndex, String label = ""}) {
+  debugStart?.call('WOWNERO_Wallet_addSubaddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_addSubaddress(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Wallet_addSubaddress');
+  return s;
+}
+
+void Wallet_addSubaddressAccount(wallet ptr, {String label = ""}) {
+  debugStart?.call('WOWNERO_Wallet_addSubaddressAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_addSubaddressAccount(ptr, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Wallet_addSubaddressAccount');
+  return s;
+}
+
+int Wallet_numSubaddressAccounts(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_numSubaddressAccounts');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final numSubaddressAccounts = lib!.WOWNERO_Wallet_numSubaddressAccounts(ptr);
+  debugEnd?.call('WOWNERO_Wallet_numSubaddressAccounts');
+  return numSubaddressAccounts;
+}
+
+int Wallet_numSubaddresses(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_numSubaddresses');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final numSubaddresses =
+      lib!.WOWNERO_Wallet_numSubaddresses(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_numSubaddresses');
+  return numSubaddresses;
+}
+
+String Wallet_getSubaddressLabel(wallet ptr,
+    {required int accountIndex, required int addressIndex}) {
+  debugStart?.call('WOWNERO_Wallet_getSubaddressLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_Wallet_getSubaddressLabel(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getSubaddressLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getSubaddressLabel', e);
+    debugEnd?.call('WOWNERO_Wallet_getSubaddressLabel');
+    return "";
+  }
+}
+
+void Wallet_setSubaddressLabel(wallet ptr,
+    {required int accountIndex,
+    required int addressIndex,
+    required String label}) {
+  debugStart?.call('WOWNERO_Wallet_setSubaddressLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_setSubaddressLabel(
+      ptr, accountIndex, addressIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Wallet_setSubaddressLabel');
+  return s;
+}
+
+String Wallet_getMultisigInfo(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getMultisigInfo');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_getMultisigInfo(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getMultisigInfo');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getMultisigInfo', e);
+    debugEnd?.call('WOWNERO_Wallet_getMultisigInfo');
+    return "";
+  }
+}
+
+PendingTransaction Wallet_createTransactionMultDest(
+  wallet wptr, {
+  required List<String> dstAddr,
+  String paymentId = "",
+  required bool isSweepAll,
+  required List<int> amounts,
+  required int mixinCount,
+  required int pendingTransactionPriority,
+  required int subaddr_account,
+  List<String> preferredInputs = const [],
+}) {
+  debugStart?.call('WOWNERO_Wallet_createTransactionMultDest');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dst_addr_list = dstAddr.join(defaultSeparatorStr).toNativeUtf8();
+  final payment_id = paymentId.toNativeUtf8();
+  final amount_list =
+      amounts.map((e) => e.toString()).join(defaultSeparatorStr).toNativeUtf8();
+  final preferredInputs_ =
+      preferredInputs.join(defaultSeparatorStr).toNativeUtf8();
+  final ret = lib!.WOWNERO_Wallet_createTransactionMultDest(
+    wptr,
+    dst_addr_list.cast(),
+    defaultSeparator,
+    payment_id.cast(),
+    isSweepAll,
+    amount_list.cast(),
+    defaultSeparator,
+    mixinCount,
+    pendingTransactionPriority,
+    subaddr_account,
+    preferredInputs_.cast(),
+    defaultSeparator,
+  );
+  calloc.free(dst_addr_list);
+  calloc.free(payment_id);
+  calloc.free(amount_list);
+  calloc.free(preferredInputs_);
+  debugEnd?.call('WOWNERO_Wallet_createTransactionMultDest');
+  return ret;
+}
+
+PendingTransaction Wallet_createTransaction(wallet ptr,
+    {required String dst_addr,
+    required String payment_id,
+    required int amount,
+    required int mixin_count,
+    required int pendingTransactionPriority,
+    required int subaddr_account,
+    List<String> preferredInputs = const []}) {
+  debugStart?.call('WOWNERO_Wallet_createTransaction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final dst_addr_ = dst_addr.toNativeUtf8().cast<Char>();
+  final payment_id_ = payment_id.toNativeUtf8().cast<Char>();
+  final preferredInputs_ =
+      preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_createTransaction(
+    ptr,
+    dst_addr_,
+    payment_id_,
+    amount,
+    mixin_count,
+    pendingTransactionPriority,
+    subaddr_account,
+    preferredInputs_,
+    defaultSeparator,
+  );
+  calloc.free(dst_addr_);
+  calloc.free(payment_id_);
+  calloc.free(preferredInputs_);
+  debugEnd?.call('WOWNERO_Wallet_createTransaction');
+  return s;
+}
+
+UnsignedTransaction Wallet_loadUnsignedTx(wallet ptr,
+    {required String unsigned_filename}) {
+  debugStart?.call('WOWNERO_Wallet_loadUnsignedTx');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final unsigned_filename_ = unsigned_filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_loadUnsignedTx(ptr, unsigned_filename_);
+  calloc.free(unsigned_filename_);
+  debugEnd?.call('WOWNERO_Wallet_loadUnsignedTx');
+  return s;
+}
+
+bool Wallet_submitTransaction(wallet ptr, String filename) {
+  debugStart?.call('WOWNERO_Wallet_submitTransaction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_submitTransaction(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_submitTransaction');
+  return s;
+}
+
+bool Wallet_hasUnknownKeyImages(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_hasUnknownKeyImages');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_Wallet_hasUnknownKeyImages(ptr);
+  debugEnd?.call('WOWNERO_Wallet_hasUnknownKeyImages');
+  return s;
+}
+
+bool Wallet_exportKeyImages(wallet ptr, String filename, {required bool all}) {
+  debugStart?.call('WOWNERO_Wallet_exportKeyImages');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_exportKeyImages(ptr, filename_, all);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_exportKeyImages');
+  return s;
+}
+
+bool Wallet_importKeyImages(wallet ptr, String filename) {
+  debugStart?.call('WOWNERO_Wallet_importKeyImages');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_importKeyImages(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_importKeyImages');
+  return s;
+}
+
+bool Wallet_exportOutputs(wallet ptr, String filename, {required bool all}) {
+  debugStart?.call('WOWNERO_Wallet_exportOutputs');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_exportOutputs(ptr, filename_, all);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_exportOutputs');
+  return s;
+}
+
+bool Wallet_importOutputs(wallet ptr, String filename) {
+  debugStart?.call('WOWNERO_Wallet_importOutputs');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_importOutputs(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_importOutputs');
+  return s;
+}
+
+bool Wallet_setupBackgroundSync(
+  wallet ptr, {
+  required int backgroundSyncType,
+  required String walletPassword,
+  required String backgroundCachePassword,
+}) {
+  debugStart?.call('WOWNERO_Wallet_setupBackgroundSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final walletPassword_ = walletPassword.toNativeUtf8().cast<Char>();
+  final backgroundCachePassword_ =
+      backgroundCachePassword.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_setupBackgroundSync(
+      ptr, backgroundSyncType, walletPassword_, backgroundCachePassword_);
+  calloc.free(walletPassword_);
+  calloc.free(backgroundCachePassword_);
+  debugEnd?.call('WOWNERO_Wallet_setupBackgroundSync');
+  return s;
+}
+
+int Wallet_getBackgroundSyncType(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getBackgroundSyncType');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_getBackgroundSyncType(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getBackgroundSyncType');
+  return v;
+}
+
+bool Wallet_startBackgroundSync(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_startBackgroundSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_startBackgroundSync(ptr);
+  debugEnd?.call('WOWNERO_Wallet_startBackgroundSync');
+  return v;
+}
+
+bool Wallet_stopBackgroundSync(wallet ptr, String walletPassword) {
+  debugStart?.call('WOWNERO_Wallet_stopBackgroundSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final walletPassword_ = walletPassword.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Wallet_stopBackgroundSync(ptr, walletPassword_);
+  calloc.free(walletPassword_);
+  debugEnd?.call('WOWNERO_Wallet_stopBackgroundSync');
+  return v;
+}
+
+bool Wallet_isBackgroundSyncing(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isBackgroundSyncing');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_isBackgroundSyncing(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isBackgroundSyncing');
+  return v;
+}
+
+bool Wallet_isBackgroundWallet(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isBackgroundWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_isBackgroundWallet(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isBackgroundWallet');
+  return v;
+}
+
+TransactionHistory Wallet_history(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_history');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_history(ptr);
+  debugEnd?.call('WOWNERO_Wallet_history');
+  return history;
+}
+
+AddressBook Wallet_addressBook(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_addressBook');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_addressBook(ptr);
+  debugEnd?.call('WOWNERO_Wallet_addressBook');
+  return history;
+}
+
+AddressBook Wallet_coins(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_coins');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_coins(ptr);
+  debugEnd?.call('WOWNERO_Wallet_coins');
+  return history;
+}
+
+AddressBook Wallet_subaddress(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_subaddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_subaddress(ptr);
+  debugEnd?.call('WOWNERO_Wallet_subaddress');
+  return history;
+}
+
+AddressBook Wallet_subaddressAccount(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_subaddressAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_subaddressAccount(ptr);
+  debugEnd?.call('WOWNERO_Wallet_subaddressAccount');
+  return history;
+}
+
+int Wallet_defaultMixin(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_defaultMixin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_defaultMixin(ptr);
+  debugEnd?.call('WOWNERO_Wallet_defaultMixin');
+  return v;
+}
+
+void Wallet_setDefaultMixin(wallet ptr, int arg) {
+  debugStart?.call('WOWNERO_Wallet_setDefaultMixin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_setDefaultMixin(ptr, arg);
+  debugEnd?.call('WOWNERO_Wallet_setDefaultMixin');
+  return v;
+}
+
+bool Wallet_setCacheAttribute(wallet ptr,
+    {required String key, required String value}) {
+  debugStart?.call('WOWNERO_Wallet_setCacheAttribute');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final key_ = key.toNativeUtf8().cast<Char>();
+  final value_ = value.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Wallet_setCacheAttribute(ptr, key_, value_);
+  calloc.free(key_);
+  calloc.free(value_);
+  debugEnd?.call('WOWNERO_Wallet_setCacheAttribute');
+  return v;
+}
+
+String Wallet_getCacheAttribute(wallet ptr, {required String key}) {
+  debugStart?.call('WOWNERO_Wallet_getCacheAttribute');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final key_ = key.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_getCacheAttribute(ptr, key_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(key_);
+    debugEnd?.call('WOWNERO_Wallet_getCacheAttribute');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getCacheAttribute', e);
+    debugEnd?.call('WOWNERO_Wallet_getCacheAttribute');
+    return "";
+  }
+}
+
+bool Wallet_setUserNote(wallet ptr,
+    {required String txid, required String note}) {
+  debugStart?.call('WOWNERO_Wallet_setUserNote');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final note_ = note.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Wallet_setUserNote(ptr, txid_, note_);
+  calloc.free(txid_);
+  calloc.free(note_);
+  debugEnd?.call('WOWNERO_Wallet_setUserNote');
+  return v;
+}
+
+String Wallet_getUserNote(wallet ptr, {required String txid}) {
+  debugStart?.call('WOWNERO_Wallet_getUserNote');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final txid_ = txid.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.WOWNERO_Wallet_getUserNote(ptr, txid_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(txid_);
+    debugEnd?.call('WOWNERO_Wallet_getUserNote');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getUserNote', e);
+    debugEnd?.call('WOWNERO_Wallet_getUserNote');
+    return "";
+  }
+}
+
+String Wallet_getTxKey(wallet ptr, {required String txid}) {
+  debugStart?.call('WOWNERO_Wallet_getTxKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final txid_ = txid.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.WOWNERO_Wallet_getTxKey(ptr, txid_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(txid_);
+    debugEnd?.call('WOWNERO_Wallet_getTxKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getTxKey', e);
+    debugEnd?.call('WOWNERO_Wallet_getTxKey');
+    return "";
+  }
+}
+
+String Wallet_signMessage(
+  wallet ptr, {
+  required String message,
+  required String address,
+}) {
+  debugStart?.call('WOWNERO_Wallet_signMessage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final message_ = message.toNativeUtf8().cast<Char>();
+    final address_ = address.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_signMessage(ptr, message_, address_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(message_);
+    calloc.free(address_);
+    debugEnd?.call('WOWNERO_Wallet_signMessage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_signMessage', e);
+    debugEnd?.call('WOWNERO_Wallet_signMessage');
+    return "";
+  }
+}
+
+bool Wallet_verifySignedMessage(
+  wallet ptr, {
+  required String message,
+  required String address,
+  required String signature,
+}) {
+  debugStart?.call('WOWNERO_Wallet_verifySignedMessage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final message_ = message.toNativeUtf8().cast<Char>();
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final signature_ = signature.toNativeUtf8().cast<Char>();
+  final v = lib!
+      .WOWNERO_Wallet_verifySignedMessage(ptr, message_, address_, signature_);
+  calloc.free(message_);
+  calloc.free(address_);
+  calloc.free(signature_);
+  debugEnd?.call('WOWNERO_Wallet_verifySignedMessage');
+  return v;
+}
+
+bool Wallet_rescanSpent(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_rescanSpent');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_rescanSpent(ptr);
+  debugEnd?.call('WOWNERO_Wallet_rescanSpent');
+  return v;
+}
+
+void Wallet_setOffline(wallet ptr, {required bool offline}) {
+  debugStart?.call('WOWNERO_Wallet_setOffline');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final setOffline = lib!.WOWNERO_Wallet_setOffline(ptr, offline);
+  debugEnd?.call('WOWNERO_Wallet_setOffline');
+  return setOffline;
+}
+
+bool Wallet_isOffline(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isOffline');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isOffline = lib!.WOWNERO_Wallet_isOffline(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isOffline');
+  return isOffline;
+}
+
+void Wallet_segregatePreForkOutputs(wallet ptr, {required bool segregate}) {
+  debugStart?.call('WOWNERO_Wallet_segregatePreForkOutputs');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_segregatePreForkOutputs(ptr, segregate);
+  debugEnd?.call('WOWNERO_Wallet_segregatePreForkOutputs');
+  return v;
+}
+
+void Wallet_segregationHeight(wallet ptr, {required int height}) {
+  debugStart?.call('WOWNERO_Wallet_segregationHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_segregationHeight(ptr, height);
+  debugEnd?.call('WOWNERO_Wallet_segregationHeight');
+  return v;
+}
+
+void Wallet_keyReuseMitigation2(wallet ptr, {required bool mitigation}) {
+  debugStart?.call('WOWNERO_Wallet_keyReuseMitigation2');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_keyReuseMitigation2(ptr, mitigation);
+  debugEnd?.call('WOWNERO_Wallet_keyReuseMitigation2');
+  return v;
+}
+
+bool Wallet_lockKeysFile(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_lockKeysFile');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_lockKeysFile(ptr);
+  debugEnd?.call('WOWNERO_Wallet_lockKeysFile');
+  return v;
+}
+
+bool Wallet_unlockKeysFile(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_unlockKeysFile');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_unlockKeysFile(ptr);
+  debugEnd?.call('WOWNERO_Wallet_unlockKeysFile');
+  return v;
+}
+
+bool Wallet_isKeysFileLocked(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isKeysFileLocked');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_isKeysFileLocked(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isKeysFileLocked');
+  return v;
+}
+
+int Wallet_getDeviceType(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getDeviceType');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_getDeviceType(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getDeviceType');
+  return v;
+}
+
+int Wallet_coldKeyImageSync(wallet ptr,
+    {required int spent, required int unspent}) {
+  debugStart?.call('WOWNERO_Wallet_coldKeyImageSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_coldKeyImageSync(ptr, spent, unspent);
+  debugEnd?.call('WOWNERO_Wallet_coldKeyImageSync');
+  return v;
+}
+
+String Wallet_deviceShowAddress(wallet ptr,
+    {required int accountIndex, required int addressIndex}) {
+  debugStart?.call('WOWNERO_Wallet_deviceShowAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_Wallet_deviceShowAddress(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_deviceShowAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_deviceShowAddress', e);
+    debugEnd?.call('WOWNERO_Wallet_deviceShowAddress');
+    return "";
+  }
+}
+
+bool Wallet_reconnectDevice(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_reconnectDevice');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.WOWNERO_Wallet_reconnectDevice(ptr);
+  return ret;
+}
+
+int Wallet_getBytesReceived(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getBytesReceived');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final getBytesReceived = lib!.WOWNERO_Wallet_getBytesReceived(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getBytesReceived');
+  return getBytesReceived;
+}
+
+int Wallet_getBytesSent(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getBytesReceived');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final getBytesSent = lib!.WOWNERO_Wallet_getBytesSent(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getBytesReceived');
+  return getBytesSent;
+}
+
+// WalletManager
+
+typedef WalletManager = Pointer<Void>;
+
+wallet WalletManager_createWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  String language = "English",
+  int networkType = 0,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_createWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_createWallet(
+      wm_ptr, path_, password_, language_, networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_WalletManager_createWallet');
+  return w;
+}
+
+wallet WalletManager_openWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_openWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final w = lib!
+      .WOWNERO_WalletManager_openWallet(wm_ptr, path_, password_, networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  debugEnd?.call('WOWNERO_WalletManager_openWallet');
+  return w;
+}
+
+wallet WalletManager_recoveryWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  required String mnemonic,
+  int networkType = 0,
+  required int restoreHeight,
+  int kdfRounds = 0,
+  required String seedOffset,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_recoveryWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final mnemonic_ = mnemonic.toNativeUtf8().cast<Char>();
+  final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_recoveryWallet(wm_ptr, path_, password_,
+      mnemonic_, networkType, restoreHeight, kdfRounds, seedOffset_);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(mnemonic_);
+  calloc.free(seedOffset_);
+  debugEnd?.call('WOWNERO_WalletManager_recoveryWallet');
+  return w;
+}
+
+wallet WalletManager_createWalletFromKeys(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  String language = "English",
+  int nettype = 1,
+  required int restoreHeight,
+  required String addressString,
+  required String viewKeyString,
+  required String spendKeyString,
+  int kdf_rounds = 1,
+}) {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  debugStart?.call('WOWNERO_WalletManager_createWalletFromKeys');
+
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final addressString_ = addressString.toNativeUtf8().cast<Char>();
+  final viewKeyString_ = viewKeyString.toNativeUtf8().cast<Char>();
+  final spendKeyString_ = spendKeyString.toNativeUtf8().cast<Char>();
+
+  final w = lib!.WOWNERO_WalletManager_createWalletFromKeys(
+    wm_ptr,
+    path_,
+    password_,
+    language_,
+    nettype,
+    restoreHeight,
+    addressString_,
+    viewKeyString_,
+    spendKeyString_,
+    kdf_rounds,
+  );
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  calloc.free(addressString_);
+  calloc.free(viewKeyString_);
+  calloc.free(spendKeyString_);
+  debugEnd?.call('WOWNERO_WalletManager_createWalletFromKeys');
+  return w;
+}
+
+wallet WalletManager_createDeterministicWalletFromSpendKey(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String language,
+  required String spendKeyString,
+  required bool newWallet,
+  required int restoreHeight,
+  int kdfRounds = 1,
+}) {
+  debugStart
+      ?.call('WOWNERO_WalletManager_createDeterministicWalletFromSpendKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final spendKeyString_ = spendKeyString.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(
+      wm_ptr,
+      path_,
+      password_,
+      language_,
+      networkType,
+      restoreHeight,
+      spendKeyString_,
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  calloc.free(spendKeyString_);
+  debugEnd?.call('WOWNERO_WalletManager_createDeterministicWalletFromSpendKey');
+  return w;
+}
+
+wallet WalletManager_createWalletFromPolyseed(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String mnemonic,
+  required String seedOffset,
+  required bool newWallet,
+  required int restoreHeight,
+  required int kdfRounds,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_createWalletFromPolyseed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final mnemonic_ = mnemonic.toNativeUtf8().cast<Char>();
+  final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_createWalletFromPolyseed(
+      wm_ptr,
+      path_,
+      password_,
+      networkType,
+      mnemonic_,
+      seedOffset_,
+      newWallet,
+      restoreHeight,
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(mnemonic_);
+  calloc.free(seedOffset_);
+  debugEnd?.call('WOWNERO_WalletManager_createWalletFromPolyseed');
+  return w;
+}
+
+bool WalletManager_closeWallet(WalletManager wm_ptr, wallet ptr, bool store) {
+  debugStart?.call('WOWNERO_WalletManager_closeWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final closeWallet =
+      lib!.WOWNERO_WalletManager_closeWallet(wm_ptr, ptr, store);
+  debugEnd?.call('WOWNERO_WalletManager_closeWallet');
+  return closeWallet;
+}
+
+bool WalletManager_walletExists(WalletManager wm_ptr, String path) {
+  debugStart?.call('WOWNERO_WalletManager_walletExists');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_walletExists(wm_ptr, path_);
+  calloc.free(path_);
+  debugEnd?.call('WOWNERO_WalletManager_walletExists');
+  return s;
+}
+
+bool WalletManager_verifyWalletPassword(
+  WalletManager wm_ptr, {
+  required String keysFileName,
+  required String password,
+  required bool noSpendKey,
+  required int kdfRounds,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_verifyWalletPassword');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final keysFileName_ = keysFileName.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_verifyWalletPassword(
+      wm_ptr, keysFileName_, password_, noSpendKey, kdfRounds);
+  calloc.free(keysFileName_);
+  calloc.free(password_);
+  debugEnd?.call('WOWNERO_WalletManager_verifyWalletPassword');
+  return s;
+}
+
+String WalletManager_findWallets(WalletManager wm_ptr, {required String path}) {
+  debugStart?.call('WOWNERO_WalletManager_findWallets');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final path_ = path.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .WOWNERO_WalletManager_findWallets(wm_ptr, path_, defaultSeparator)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    calloc.free(path_);
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_WalletManager_findWallets');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_WalletManager_findWallets', e);
+    debugEnd?.call('WOWNERO_WalletManager_findWallets');
+    return "";
+  }
+}
+
+String WalletManager_errorString(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_errorString');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_WalletManager_errorString(wm_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_WalletManager_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_WalletManager_errorString', e);
+    debugEnd?.call('WOWNERO_WalletManager_errorString');
+    return "";
+  }
+}
+
+void WalletManager_setDaemonAddress(WalletManager wm_ptr, String address) {
+  debugStart?.call('WOWNERO_WalletManager_setDaemonAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_setDaemonAddress(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_setDaemonAddress');
+  return s;
+}
+
+int WalletManager_blockchainHeight(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_blockchainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_blockchainHeight(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_blockchainHeight');
+  return s;
+}
+
+int WalletManager_blockchainTargetHeight(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_blockchainTargetHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_blockchainTargetHeight(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_blockchainTargetHeight');
+  return s;
+}
+
+int WalletManager_networkDifficulty(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_networkDifficulty');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_networkDifficulty(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_networkDifficulty');
+  return s;
+}
+
+double WalletManager_miningHashRate(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_miningHashRate');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_miningHashRate(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_miningHashRate');
+  return s;
+}
+
+int WalletManager_blockTarget(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_blockTarget');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_blockTarget(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_blockTarget');
+  return s;
+}
+
+bool WalletManager_isMining(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_isMining');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_isMining(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_isMining');
+  return s;
+}
+
+bool WalletManager_startMining(
+  WalletManager wm_ptr, {
+  required String address,
+  required int threads,
+  required bool backgroundMining,
+  required bool ignoreBattery,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_startMining');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_startMining(
+      wm_ptr, address_, threads, backgroundMining, ignoreBattery);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_startMining');
+  return s;
+}
+
+bool WalletManager_stopMining(WalletManager wm_ptr, String address) {
+  debugStart?.call('WOWNERO_WalletManager_stopMining');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_stopMining(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_stopMining');
+  return s;
+}
+
+String WalletManager_resolveOpenAlias(
+  WalletManager wm_ptr, {
+  required String address,
+  required bool dnssecValid,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_resolveOpenAlias');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final address_ = address.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .WOWNERO_WalletManager_resolveOpenAlias(wm_ptr, address_, dnssecValid)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_WalletManager_resolveOpenAlias');
+    calloc.free(address_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_WalletManager_resolveOpenAlias', e);
+    debugEnd?.call('WOWNERO_WalletManager_resolveOpenAlias');
+    return "";
+  }
+}
+
+bool WalletManager_setProxy(WalletManager wm_ptr, String address) {
+  debugStart?.call('WOWNERO_WalletManager_setProxy');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_setProxy(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_setProxy');
+  return s;
+}
+
+void WalletManagerFactory_setLogLevel(int level) {
+  debugStart?.call('WOWNERO_WalletManagerFactory_setLogLevel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManagerFactory_setLogLevel(level);
+  debugEnd?.call('WOWNERO_WalletManagerFactory_setLogLevel');
+  return s;
+}
+
+void WalletManagerFactory_setLogCategories(String categories) {
+  debugStart?.call('WOWNERO_WalletManagerFactory_setLogCategories');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final categories_ = categories.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManagerFactory_setLogCategories(categories_);
+  calloc.free(categories_);
+  debugEnd?.call('WOWNERO_WalletManagerFactory_setLogCategories');
+  return s;
+}
+
+WalletManager WalletManagerFactory_getWalletManager() {
+  debugStart?.call('WOWNERO_WalletManagerFactory_getWalletManager');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManagerFactory_getWalletManager();
+  debugEnd?.call('WOWNERO_WalletManagerFactory_getWalletManager');
+  return s;
+}
+
+// class LogLevel {
+//   int get LogLevel_Silent => lib!.LogLevel_Silent;
+//   int get LogLevel_0 => lib!.LogLevel_0;
+//   int get LogLevel_1 => lib!.LogLevel_1;
+//   int get LogLevel_2 => lib!.LogLevel_2;
+//   int get LogLevel_3 => lib!.LogLevel_3;
+//   int get LogLevel_4 => lib!.LogLevel_4;
+//   int get LogLevel_Min => LogLevel_Silent;
+//   int get LogLevel_Max => lib!.LogLevel_4;
+// }
+
+// class ConnectionStatus {
+//   int get Disconnected => lib!.WalletConnectionStatus_Disconnected;
+//   int get Connected => lib!.WalletConnectionStatus_Connected;
+//   int get WrongVersion => lib!.WalletConnectionStatus_WrongVersion;
+// }
+
+// DEBUG
+
+class libOk {
+  libOk(
+    this.test1,
+    this.test2,
+    this.test3,
+    this.test4,
+    this.test5,
+    this.test5_std,
+  );
+  final bool test1;
+  final int test2;
+  final int test3;
+  final Pointer<Void> test4;
+  final Pointer<Char> test5;
+  String get test5_str {
+    try {
+      return test5.cast<Utf8>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  String get test5_str16 {
+    try {
+      return test5.cast<Utf16>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  final Pointer<Char> test5_std;
+  String get test5_std_str {
+    try {
+      return test5_std.cast<Utf8>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  String get test5_std_str16 {
+    try {
+      return test5_std.cast<Utf16>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      "test1": test1,
+      "test2": test2,
+      "test3": test3,
+      "test4": test4.toString(),
+      "test5": test5.toString(),
+      "test5_str": test5_str,
+      "test5_std": test5_std.toString(),
+      "test5_std_str": test5_std_str,
+    };
+  }
+}
+
+libOk isLibOk() {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  lib!.WOWNERO_DEBUG_test0();
+  final test1 = lib!.WOWNERO_DEBUG_test1(true);
+  final test2 = lib!.WOWNERO_DEBUG_test2(-1);
+  final test3 = lib!.WOWNERO_DEBUG_test3(1);
+  final test4 = lib!.WOWNERO_DEBUG_test4(1);
+  final test5 = lib!.WOWNERO_DEBUG_test5();
+  final test5_std = lib!.WOWNERO_DEBUG_test5_std();
+  return libOk(test1, test2, test3, test4, test5, test5_std);
+}
+
+// cake world
+
+typedef WalletListener = Pointer<Void>;
+
+WalletListener WOWNERO_cw_getWalletListener(wallet wptr) {
+  debugStart?.call('WOWNERO_cw_getWalletListener');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_getWalletListener(wptr);
+  debugEnd?.call('WOWNERO_cw_getWalletListener');
+  return s;
+}
+
+void WOWNERO_cw_WalletListener_resetNeedToRefresh(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_resetNeedToRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_resetNeedToRefresh(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_resetNeedToRefresh');
+  return s;
+}
+
+bool WOWNERO_cw_WalletListener_isNeedToRefresh(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_isNeedToRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_isNeedToRefresh(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_isNeedToRefresh');
+  return s;
+}
+
+bool WOWNERO_cw_WalletListener_isNewTransactionExist(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_isNewTransactionExist');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_isNewTransactionExist(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_isNewTransactionExist');
+  return s;
+}
+
+void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(
+    WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_resetIsNewTransactionExist');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_resetIsNewTransactionExist(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_resetIsNewTransactionExist');
+  return s;
+}
+
+int WOWNERO_cw_WalletListener_height(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_height');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_height(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_height');
+  return s;
+}
+
+wallet WOWNERO_deprecated_restore14WordSeed({
+  required String path,
+  required String password,
+  required String language,
+  required int networkType,
+}) {
+  debugStart?.call('WOWNERO_deprecated_restore14WordSeed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8();
+  final password_ = password.toNativeUtf8();
+  final language_ = language.toNativeUtf8();
+  final s = lib!.WOWNERO_deprecated_restore14WordSeed(
+      path_.cast(), password_.cast(), language_.cast(), networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_deprecated_restore14WordSeed');
+  return s;
+}
+
+wallet WOWNERO_deprecated_create14WordSeed({
+  required String path,
+  required String password,
+  required String language,
+  required int networkType,
+}) {
+  debugStart?.call('WOWNERO_deprecated_create14WordSeed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8();
+  final password_ = path.toNativeUtf8();
+  final language_ = path.toNativeUtf8();
+  final s = lib!.WOWNERO_deprecated_create14WordSeed(
+      path_.cast(), password_.cast(), language_.cast(), networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_deprecated_create14WordSeed');
+  return s;
+}
+
+int WOWNERO_deprecated_14WordSeedHeight({
+  required String seed,
+}) {
+  debugStart?.call('WOWNERO_deprecated_14WordSeedHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final seed_ = seed.toNativeUtf8();
+  final s = lib!.WOWNERO_deprecated_14WordSeedHeight(seed_.cast());
+  calloc.free(seed_);
+  debugEnd?.call('WOWNERO_deprecated_14WordSeedHeight');
+  return s;
+}
+
+void WOWNERO_free(Pointer<Void> wlptr) {
+  debugStart?.call('WOWNERO_free');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_free(wlptr);
+  debugEnd?.call('WOWNERO_free');
+  return s;
+}