path: root/impls/monero.dart/lib/wownero.dart

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';

export 'src/checksum_wownero.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;
}


String WOWNERO_checksum_wallet2_api_c_h() {
  debugStart?.call('WOWNERO_checksum_wallet2_api_c_h');
  lib ??= WowneroC(DynamicLibrary.open(libPath));

  final s = lib!.WOWNERO_checksum_wallet2_api_c_h();
  debugEnd?.call('WOWNERO_checksum_wallet2_api_c_h');
  return s.cast<Utf8>().toDartString();
}

String WOWNERO_checksum_wallet2_api_c_cpp() {
  debugStart?.call('WOWNERO_checksum_wallet2_api_c_cpp');
  lib ??= WowneroC(DynamicLibrary.open(libPath));

  final s = lib!.WOWNERO_checksum_wallet2_api_c_cpp();
  debugEnd?.call('WOWNERO_checksum_wallet2_api_c_cpp');
  return s.cast<Utf8>().toDartString();
}

String WOWNERO_checksum_wallet2_api_c_exp() {
  debugStart?.call('WOWNERO_checksum_wallet2_api_c_exp');
  lib ??= WowneroC(DynamicLibrary.open(libPath));

  final s = lib!.WOWNERO_checksum_wallet2_api_c_exp();
  debugEnd?.call('WOWNERO_checksum_wallet2_api_c_exp');
  return s.cast<Utf8>().toDartString();
}

int WOWNERO_checksum_wallet2_api_c_version() {
  debugStart?.call('WOWNERO_checksum_wallet2_api_c_version');
  lib ??= WowneroC(DynamicLibrary.open(libPath));

  final s = lib!.WOWNERO_checksum_wallet2_api_c_version();
  debugEnd?.call('WOWNERO_checksum_wallet2_api_c_version');
  return s;
}

String WOWNERO_checksum_wallet2_api_c_date() {
  debugStart?.call('WOWNERO_checksum_wallet2_api_c_date');
  lib ??= WowneroC(DynamicLibrary.open(libPath));

  final s = lib!.WOWNERO_checksum_wallet2_api_c_date();
  debugEnd?.call('WOWNERO_checksum_wallet2_api_c_date');
  return s.cast<Utf8>().toDartString();
}


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;
}