oo-monerodart

3 files changed, 3607 insertions, 0 deletions

diff --git a/impls/monero.dart/lib/src/monero.dart b/impls/monero.dart/lib/src/monero.dart
new file mode 100644
index 0000000..76fee3b
--- /dev/null
+++ b/impls/monero.dart/lib/src/monero.dart
@@ -0,0 +1,1619 @@
+// ignore_for_file: deprecated_member_use_from_same_package
+
+import 'dart:ffi';
+
+import 'package:monero/monero.dart' as monero;
+import 'package:monero/src/wallet2.dart';
+
+class Monero implements Wallet2 {
+  @override
+  Wallet2WalletManagerFactory walletManagerFactory() {
+    return MoneroWalletManagerFactory();
+  }
+
+}
+
+class MoneroAddressBook implements Wallet2AddressBook {
+  MoneroAddressBook(this.addressBookPtr);
+
+  final monero.AddressBook addressBookPtr;
+  
+  @override
+  bool addRow({required String dstAddr, required String paymentId, required String description}) {
+    return monero.AddressBook_addRow(addressBookPtr, dstAddr: dstAddr, paymentId: paymentId, description: description);
+  }
+  
+  @override
+  bool deleteRow({required int rowId}) {
+    return monero.AddressBook_deleteRow(addressBookPtr, rowId: rowId);
+  }
+  
+  @override
+  int errorCode() {
+    return monero.AddressBook_errorCode(addressBookPtr);
+  }
+  
+  @override
+  Wallet2AddressBookRow getAll_byIndex(int index) {
+    final row = monero.AddressBook_getAll_byIndex(addressBookPtr, index: index);
+    return MoneroAddressBookRow(row);
+  }
+  
+  @override
+  int getAll_size() {
+    return monero.AddressBook_getAll_size(addressBookPtr);
+  }
+  
+  @override
+  int lookupPaymentID({required String paymentId}) {
+    return monero.AddressBook_lookupPaymentID(addressBookPtr, paymentId: paymentId);
+  }
+  
+  @override
+  void refresh() {
+    monero.AddressBook_refresh(addressBookPtr);
+  }
+  
+  @override
+  bool setDescription({required int rowId, required String description}) {
+    return monero.AddressBook_setDescription(addressBookPtr, rowId: rowId, description: description);
+  }
+}
+
+class MoneroAddressBookRow implements Wallet2AddressBookRow {
+  MoneroAddressBookRow(this.addressBookRowPtr);
+
+  final monero.AddressBookRow addressBookRowPtr;
+  
+  @override
+  String extra() {
+    return monero.AddressBookRow_extra(addressBookRowPtr);
+  }
+  
+  @override
+  String getAddress() {
+    return monero.AddressBookRow_getAddress(addressBookRowPtr);
+  }
+  
+  @override
+  String getDescription() {
+    return monero.AddressBookRow_getDescription(addressBookRowPtr);
+  }
+  
+  @override
+  String getPaymentId() {
+    return monero.AddressBookRow_getPaymentId(addressBookRowPtr);
+  }
+  
+  @override
+  int getRowId() {
+    return monero.AddressBookRow_getRowId(addressBookRowPtr);
+  }
+}
+
+class MoneroCoins implements Wallet2Coins {
+  MoneroCoins(this.coinsPtr);
+
+  final monero.Coins coinsPtr;
+  
+  @override
+  Wallet2CoinsInfo coin(int index) {
+    final coin = monero.Coins_coin(coinsPtr, index);
+    return MoneroCoinsInfo(coin);
+  }
+  
+  @override
+  int count() {
+    return monero.Coins_count(coinsPtr);
+  }
+  
+  @override
+  Wallet2CoinsInfo getAll_byIndex(int index) {
+    final coin = monero.Coins_getAll_byIndex(coinsPtr, index);
+    return MoneroCoinsInfo(coin);
+  }
+  
+  @override
+  int getAll_size() {
+    return monero.Coins_getAll_size(coinsPtr);
+  }
+  
+  @override
+  bool isTransferUnlocked({required int unlockTime, required int blockHeight}) {
+    return monero.Coins_isTransferUnlocked(coinsPtr, unlockTime: unlockTime, blockHeight: blockHeight);
+  }
+  
+  @override
+  void refresh() {
+    monero.Coins_refresh(coinsPtr);
+  }
+  
+  @override
+  void setFrozen({required int index}) {
+    monero.Coins_setFrozen(coinsPtr, index: index);
+  }
+  
+  @override
+  void setFrozenByPublicKey({required String publicKey}) {
+    monero.Coins_setFrozenByPublicKey(coinsPtr, publicKey: publicKey);
+  }
+  
+  @override
+  void thaw({required int index}) {
+    monero.Coins_thaw(coinsPtr, index: index);
+  }
+  
+  @override
+  void thawByPublicKey({required String publicKey}) {
+    monero.Coins_thawByPublicKey(coinsPtr, publicKey: publicKey);
+  }
+}
+
+class MoneroCoinsInfo implements Wallet2CoinsInfo {
+  MoneroCoinsInfo(this.coinsInfoPtr);
+
+  final monero.CoinsInfo coinsInfoPtr;
+  
+  @override
+  String address() {
+    return monero.CoinsInfo_address(coinsInfoPtr);
+  }
+  
+  @override
+  String addressLabel() {
+    return monero.CoinsInfo_addressLabel(coinsInfoPtr);
+  }
+  
+  @override
+  int amount() {
+    return monero.CoinsInfo_amount(coinsInfoPtr);
+  }
+  
+  @override
+  int blockHeight() {
+    return monero.CoinsInfo_blockHeight(coinsInfoPtr);
+  }
+  
+  @override
+  bool coinbase() {
+    return monero.CoinsInfo_coinbase(coinsInfoPtr);
+  }
+  
+  @override
+  String description() {
+    return monero.CoinsInfo_description(coinsInfoPtr);
+  }
+  
+  @override
+  bool frozen() {
+    return monero.CoinsInfo_frozen(coinsInfoPtr);
+  }
+  
+  @override
+  int globalOutputIndex() {
+    return monero.CoinsInfo_globalOutputIndex(coinsInfoPtr);
+  }
+  
+  @override
+  String hash() {
+    return monero.CoinsInfo_hash(coinsInfoPtr);
+  }
+  
+  @override
+  int internalOutputIndex() {
+    return monero.CoinsInfo_internalOutputIndex(coinsInfoPtr);
+  }
+  
+  @override
+  String keyImage() {
+    return monero.CoinsInfo_keyImage(coinsInfoPtr);
+  }
+  
+  @override
+  bool keyImageKnown() {
+    return monero.CoinsInfo_keyImageKnown(coinsInfoPtr);
+  }
+  
+  @override
+  int pkIndex() {
+    return monero.CoinsInfo_pkIndex(coinsInfoPtr);
+  }
+  
+  @override
+  String pubKey() {
+    return monero.CoinsInfo_pubKey(coinsInfoPtr);
+  }
+  
+  @override
+  bool rct() {
+    return monero.CoinsInfo_rct(coinsInfoPtr);
+  }
+  
+  @override
+  bool spent() {
+    return monero.CoinsInfo_spent(coinsInfoPtr);
+  }
+  
+  @override
+  int spentHeight() {
+    return monero.CoinsInfo_spentHeight(coinsInfoPtr);
+  }
+  
+  @override
+  int subaddrAccount() {
+    return monero.CoinsInfo_subaddrAccount(coinsInfoPtr);
+  }
+  
+  @override
+  int subaddrIndex() {
+    return monero.CoinsInfo_subaddrIndex(coinsInfoPtr);
+  }
+  
+  @override
+  int unlockTime() {
+    return monero.CoinsInfo_unlockTime(coinsInfoPtr);
+  }
+  
+  @override
+  bool unlocked() {
+    return monero.CoinsInfo_unlocked(coinsInfoPtr);
+  }
+}
+
+class MoneroDeviceProgress implements Wallet2DeviceProgress {
+  MoneroDeviceProgress(this.deviceProgressPtr);
+
+  final monero.DeviceProgress deviceProgressPtr;
+  
+  @override
+  bool indeterminate() {
+    return monero.DeviceProgress_indeterminate(deviceProgressPtr);
+  }
+  
+  @override
+  bool progress() {
+    return monero.DeviceProgress_progress(deviceProgressPtr);
+  }
+}
+
+class MoneroWalletListener implements Wallet2WalletListener {
+  MoneroWalletListener(this.walletListenerPtr);
+
+  final monero.WalletListener walletListenerPtr;
+  
+  @override
+  int height() {
+    return monero.MONERO_cw_WalletListener_height(walletListenerPtr);
+  }
+  
+  @override
+  bool isNeedToRefresh() {
+    return monero.MONERO_cw_WalletListener_isNeedToRefresh(walletListenerPtr);
+  }
+  
+  @override
+  bool isNewTransactionExist() {
+    return monero.MONERO_cw_WalletListener_isNewTransactionExist(walletListenerPtr);
+  }
+  
+  @override
+  void resetIsNewTransactionExist() {
+    monero.MONERO_cw_WalletListener_resetIsNewTransactionExist(walletListenerPtr);
+  }
+  
+  @override
+  void resetNeedToRefresh() {
+    monero.MONERO_cw_WalletListener_resetNeedToRefresh(walletListenerPtr);
+  }
+}
+
+class MoneroWalletChecksum implements Wallet2Checksum {
+  MoneroWalletChecksum();
+
+  @override
+  String checksum_wallet2_api_c_cpp() {
+    return monero.MONERO_checksum_wallet2_api_c_cpp();
+  }
+  
+  @override
+  String checksum_wallet2_api_c_exp() {
+    return monero.MONERO_checksum_wallet2_api_c_exp();
+  }
+  
+  @override
+  String checksum_wallet2_api_c_h() {
+    return monero.MONERO_checksum_wallet2_api_c_h();
+  }
+}
+
+class MoneroFree implements Wallet2Free {
+  MoneroFree();
+
+  @override
+  void free(Pointer<Void> ptr) {
+    monero.MONERO_free(ptr);
+  }
+}
+
+class MoneroMultisigState implements Wallet2MultisigState {
+  MoneroMultisigState(this.multisigStatePtr);
+
+  final monero.MultisigState multisigStatePtr;
+  
+  @override
+  bool isMultisig(Pointer<Void> ptr) {
+    return monero.MultisigState_isMultisig(multisigStatePtr);
+  }
+  
+  @override
+  bool isReady(Pointer<Void> ptr) {
+    return monero.MultisigState_isReady(multisigStatePtr);
+  }
+  
+  @override
+  int threshold(Pointer<Void> ptr) {
+    return monero.MultisigState_threshold(multisigStatePtr);
+  }
+  
+  @override
+  int total(Pointer<Void> ptr) {
+    return monero.MultisigState_total(multisigStatePtr);
+  }
+}
+
+class MoneroPendingTransaction implements Wallet2PendingTransaction {
+  MoneroPendingTransaction(this.pendingTransactionPtr);
+
+  final monero.PendingTransaction pendingTransactionPtr;
+  
+  @override
+  int amount() {
+    return monero.PendingTransaction_amount(pendingTransactionPtr);
+  }
+  
+  @override
+  bool commit({required String filename, required bool overwrite}) {
+    return monero.PendingTransaction_commit(pendingTransactionPtr, filename: filename, overwrite: overwrite);
+  }
+  
+  @override
+  String commitUR(int max_fragment_length) {
+    return monero.PendingTransaction_commitUR(pendingTransactionPtr, max_fragment_length);
+  }
+  
+  @override
+  int dust() {
+    return monero.PendingTransaction_dust(pendingTransactionPtr);
+  }
+  
+  @override
+  String errorString() {
+    return monero.PendingTransaction_errorString(pendingTransactionPtr);
+  }
+  
+  @override
+  int fee() {
+    return monero.PendingTransaction_fee(pendingTransactionPtr);
+  }
+  
+  @override
+  String hex(String separator) {
+    return monero.PendingTransaction_hex(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  String multisigSignData() {
+    return monero.PendingTransaction_multisigSignData(pendingTransactionPtr);
+  }
+  
+  @override
+  void signMultisigTx() {
+    monero.PendingTransaction_signMultisigTx(pendingTransactionPtr);
+  }
+  
+  @override
+  String signersKeys(String separator) {
+    return monero.PendingTransaction_signersKeys(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  int status() {
+    return monero.PendingTransaction_status(pendingTransactionPtr);
+  }
+  
+  @override
+  String subaddrAccount(String separator) {
+    return monero.PendingTransaction_subaddrAccount(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  String subaddrIndices(String separator) {
+    return monero.PendingTransaction_subaddrIndices(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  int txCount() {
+    return monero.PendingTransaction_txCount(pendingTransactionPtr);
+  }
+  
+  @override
+  String txid(String separator) {
+    return monero.PendingTransaction_txid(pendingTransactionPtr, separator);
+  }
+}
+
+class MoneroSubaddress implements Wallet2Subaddress {
+  MoneroSubaddress(this.subaddressPtr);
+
+  final monero.Subaddress subaddressPtr;
+  
+  @override
+  void addRow({required int accountIndex, required String label}) {
+    monero.Subaddress_addRow(subaddressPtr, accountIndex: accountIndex, label: label);
+  }
+  
+  @override
+  Wallet2SubaddressRow getAll_byIndex(int index) {
+    final row = monero.Subaddress_getAll_byIndex(subaddressPtr, index: index);
+    return MoneroSubaddressRow(row);
+  }
+  
+  @override
+  int getAll_size() {
+    return monero.Subaddress_getAll_size(subaddressPtr);
+  }
+  
+  @override
+  void refresh({required int accountIndex, required String label}) {
+    monero.Subaddress_refresh(subaddressPtr, accountIndex: accountIndex, label: label);
+  }
+  
+  @override
+  void setLabel({required int accountIndex, required int addressIndex, required String label}) {
+    monero.Subaddress_setLabel(subaddressPtr, accountIndex: accountIndex, addressIndex: addressIndex, label: label);
+  }
+}
+
+class MoneroSubaddressAccount implements Wallet2SubaddressAccount {
+  MoneroSubaddressAccount(this.subaddressAccountPtr);
+
+  final monero.SubaddressAccount subaddressAccountPtr;
+  
+  @override
+  void addRow({required String label}) {
+    monero.SubaddressAccount_addRow(subaddressAccountPtr, label: label);
+  }
+  
+  @override
+  Wallet2SubaddressAccountRow getAll_byIndex(int index) {
+    final row = monero.SubaddressAccount_getAll_byIndex(subaddressAccountPtr, index: index);
+    return MoneroSubaddressAccountRow(row);
+  }
+  
+  @override
+  int getAll_size() {
+    return monero.SubaddressAccount_getAll_size(subaddressAccountPtr);
+  }
+  
+  @override
+  void refresh() {
+    monero.SubaddressAccount_refresh(subaddressAccountPtr);
+  }
+  
+  @override
+  void setLabel({required int accountIndex, required String label}) {
+    monero.SubaddressAccount_setLabel(subaddressAccountPtr, accountIndex: accountIndex, label: label);
+  }
+}
+
+class MoneroSubaddressAccountRow implements Wallet2SubaddressAccountRow {
+  MoneroSubaddressAccountRow(this.subaddressAccountRowPtr);
+
+  final monero.SubaddressAccountRow subaddressAccountRowPtr;
+  
+  @override
+  String extra() {
+    return monero.SubaddressAccountRow_extra(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getAddress() {
+    return monero.SubaddressAccountRow_getAddress(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getBalance() {
+    return monero.SubaddressAccountRow_getBalance(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getLabel() {
+    return monero.SubaddressAccountRow_getLabel(subaddressAccountRowPtr);
+  }
+  
+  @override
+  int getRowId() {
+    return monero.SubaddressAccountRow_getRowId(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getUnlockedBalance() {
+    return monero.SubaddressAccountRow_getUnlockedBalance(subaddressAccountRowPtr);
+  }
+}
+
+class MoneroSubaddressRow implements Wallet2SubaddressRow {
+  MoneroSubaddressRow(this.subaddressRowPtr);
+
+  final monero.SubaddressRow subaddressRowPtr;
+  
+  @override
+  String extra() {
+    return monero.SubaddressRow_extra(subaddressRowPtr);
+  }
+  
+  @override
+  String getAddress() {
+    return monero.SubaddressRow_getAddress(subaddressRowPtr);
+  }
+  
+  @override
+  String getLabel() {
+    return monero.SubaddressRow_getLabel(subaddressRowPtr);
+  }
+  
+  @override
+  int getRowId() {
+    return monero.SubaddressRow_getRowId(subaddressRowPtr);
+  }
+}
+
+class MoneroTransactionHistory implements Wallet2TransactionHistory {
+  MoneroTransactionHistory(this.transactionHistoryPtr);
+
+  final monero.TransactionHistory transactionHistoryPtr;
+  
+  @override
+  int count() {
+    return monero.TransactionHistory_count(transactionHistoryPtr);
+  }
+  
+  @override
+  void refresh() {
+    monero.TransactionHistory_refresh(transactionHistoryPtr);
+  }
+  
+  @override
+  void setTxNote({required String txid, required String note}) {
+    monero.TransactionHistory_setTxNote(transactionHistoryPtr, txid: txid, note: note);
+  }
+  
+  @override
+  Wallet2TransactionInfo transaction(int index) {
+    final tx = monero.TransactionHistory_transaction(transactionHistoryPtr, index: index);
+    return MoneroTransactionInfo(tx);
+  }
+  
+  @override
+  Wallet2TransactionInfo transactionById(String txid) {
+    final tx = monero.TransactionHistory_transactionById(transactionHistoryPtr, txid: txid);
+    return MoneroTransactionInfo(tx);
+  }
+}
+
+class MoneroTransactionInfo implements Wallet2TransactionInfo {
+  MoneroTransactionInfo(this.transactionInfoPtr);
+
+  final monero.TransactionInfo transactionInfoPtr;
+  
+  @override
+  int amount() {
+    return monero.TransactionInfo_amount(transactionInfoPtr);
+  }
+  
+  @override
+  int blockHeight() {
+    return monero.TransactionInfo_blockHeight(transactionInfoPtr);
+  }
+  
+  @override
+  int confirmations() {
+    return monero.TransactionInfo_confirmations(transactionInfoPtr);
+  }
+  
+  @override
+  String description() {
+    return monero.TransactionInfo_description(transactionInfoPtr);
+  }
+  
+  @override
+  int direction() {
+    return monero.TransactionInfo_direction(transactionInfoPtr).index;
+  }
+  
+  @override
+  int fee() {
+    return monero.TransactionInfo_fee(transactionInfoPtr);
+  }
+  
+  @override
+  String hash() {
+    return monero.TransactionInfo_hash(transactionInfoPtr);
+  }
+  
+  @override
+  bool isCoinbase() {
+    return monero.TransactionInfo_isCoinbase(transactionInfoPtr);
+  }
+  
+  @override
+  bool isFailed() {
+    return monero.TransactionInfo_isFailed(transactionInfoPtr);
+  }
+  
+  @override
+  bool isPending() {
+    return monero.TransactionInfo_isPending(transactionInfoPtr);
+  }
+  
+  @override
+  String label() {
+    return monero.TransactionInfo_label(transactionInfoPtr);
+  }
+  
+  @override
+  String paymentId() {
+    return monero.TransactionInfo_paymentId(transactionInfoPtr);
+  }
+  
+  @override
+  int subaddrAccount() {
+    return monero.TransactionInfo_subaddrAccount(transactionInfoPtr);
+  }
+  
+  @override
+  String subaddrIndex() {
+    return monero.TransactionInfo_subaddrIndex(transactionInfoPtr);
+  }
+  
+  @override
+  int timestamp() {
+    return monero.TransactionInfo_timestamp(transactionInfoPtr);
+  }
+  
+  @override
+  String transfers_address(int index) {
+    return monero.TransactionInfo_transfers_address(transactionInfoPtr, index);
+  }
+  
+  @override
+  int transfers_amount(int index) {
+    return monero.TransactionInfo_transfers_amount(transactionInfoPtr, index);
+  }
+  
+  @override
+  int transfers_count() {
+    return monero.TransactionInfo_transfers_count(transactionInfoPtr);
+  }
+  
+  @override
+  int unlockTime() {
+    return monero.TransactionInfo_unlockTime(transactionInfoPtr);
+  }
+  
+}
+
+class MoneroUnsignedTransaction implements Wallet2UnsignedTransaction {
+  MoneroUnsignedTransaction(this.unsignedTransactionPtr);
+
+  final monero.UnsignedTransaction unsignedTransactionPtr;
+  
+  @override
+  String amount() {
+    return monero.UnsignedTransaction_amount(unsignedTransactionPtr);
+  }
+  
+  @override
+  String confirmationMessage() {
+    return monero.UnsignedTransaction_confirmationMessage(unsignedTransactionPtr);
+  }
+  
+  @override
+  String errorString() {
+    return monero.UnsignedTransaction_errorString(unsignedTransactionPtr);
+  }
+  
+  @override
+  String fee() {
+    return monero.UnsignedTransaction_fee(unsignedTransactionPtr);
+  }
+  
+  @override
+  int minMixinCount() {
+    return monero.UnsignedTransaction_minMixinCount(unsignedTransactionPtr);
+  }
+  
+  @override
+  String mixin() {
+    return monero.UnsignedTransaction_mixin(unsignedTransactionPtr);
+  }
+  
+  @override
+  String paymentId() {
+    return monero.UnsignedTransaction_paymentId(unsignedTransactionPtr);
+  }
+  
+  @override
+  String recipientAddress() {
+    return monero.UnsignedTransaction_recipientAddress(unsignedTransactionPtr);
+  }
+  
+  @override
+  bool sign(String signedFileName) {
+    return monero.UnsignedTransaction_sign(unsignedTransactionPtr, signedFileName);
+  }
+  
+  @override
+  String signUR(int max_fragment_length) {
+    return monero.UnsignedTransaction_signUR(unsignedTransactionPtr, max_fragment_length);
+  }
+  
+  @override
+  int status() {
+    return monero.UnsignedTransaction_status(unsignedTransactionPtr);
+  }
+  
+  @override
+  int txCount() {
+    return monero.UnsignedTransaction_txCount(unsignedTransactionPtr);
+  }
+  
+  
+}
+
+class MoneroWallet implements Wallet2Wallet {
+  MoneroWallet(this.walletPtr);
+
+  final monero.wallet walletPtr;
+  
+  @override
+  void addSubaddress({required int accountIndex, String label = ""}) {
+    monero.Wallet_addSubaddress(walletPtr, accountIndex: accountIndex, label: label);
+  }
+  
+  @override
+  void addSubaddressAccount({String label = ""}) {
+    monero.Wallet_addSubaddressAccount(walletPtr, label: label);
+  }
+  
+  @override
+  String address({int accountIndex = 0, int addressIndex = 0}) {
+    return monero.Wallet_address(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex);
+  }
+  
+  @override
+  Wallet2AddressBook addressBook() {
+    return MoneroAddressBook(monero.Wallet_addressBook(walletPtr));
+  }
+  
+  @override
+  bool addressValid(String address, int networkType) {
+    return monero.Wallet_addressValid(address, networkType);
+  }
+  
+  @override
+  int amountFromDouble(double amount) {
+    return monero.Wallet_amountFromDouble(amount);
+  }
+  
+  @override
+  int amountFromString(String amount) {
+    return monero.Wallet_amountFromString(amount);
+  }
+  
+  @override
+  int approximateBlockChainHeight() {
+    return monero.Wallet_approximateBlockChainHeight(walletPtr);
+  }
+  
+  @override
+  int autoRefreshInterval() {
+    return monero.Wallet_autoRefreshInterval(walletPtr);
+  }
+  
+  @override
+  int balance({required int accountIndex}) {
+    return monero.Wallet_balance(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  int blockChainHeight() {
+    return monero.Wallet_blockChainHeight(walletPtr);
+  }
+  
+  @override
+  Wallet2Coins coins() {
+    return MoneroCoins(monero.Wallet_coins(walletPtr));
+  }
+  
+  @override
+  int coldKeyImageSync({required int spent, required int unspent}) {
+    return monero.Wallet_coldKeyImageSync(walletPtr, spent: spent, unspent: unspent);
+  }
+  
+  @override
+  bool connectToDaemon() {
+    return monero.Wallet_connectToDaemon(walletPtr);
+  }
+  
+  @override
+  int connected() {
+    return monero.Wallet_connected(walletPtr);
+  }
+  
+  @override
+  String createPolyseed({String language = "English"}) {
+    return monero.Wallet_createPolyseed(language: language);
+  }
+  
+  @override
+  Wallet2PendingTransaction createTransaction({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 []}) {
+    final transaction = monero.Wallet_createTransaction(walletPtr, dst_addr: dst_addr, payment_id: payment_id, amount: amount, mixin_count: mixin_count, pendingTransactionPriority: pendingTransactionPriority, subaddr_account: subaddr_account, preferredInputs: preferredInputs);
+    return MoneroPendingTransaction(transaction);
+  }
+  
+  @override
+  Wallet2PendingTransaction createTransactionMultDest({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 []}) {
+    final transaction = monero.Wallet_createTransactionMultDest(walletPtr, dstAddr: dstAddr, paymentId: paymentId, isSweepAll: isSweepAll, amounts: amounts, mixinCount: mixinCount, pendingTransactionPriority: pendingTransactionPriority, subaddr_account: subaddr_account, preferredInputs: preferredInputs);
+    return MoneroPendingTransaction(transaction);
+  }
+  
+  @override
+  bool createWatchOnly({required String path, required String password, required String language}) {
+    return monero.Wallet_createWatchOnly(walletPtr, path: path, password: password, language: language);
+  }
+  
+  @override
+  int daemonBlockChainHeight() {
+    return monero.Wallet_daemonBlockChainHeight(walletPtr);
+  }
+  
+  @override
+  int defaultMixin() {
+    return monero.Wallet_defaultMixin(walletPtr);
+  }
+  
+  @override
+  String deviceShowAddress({required int accountIndex, required int addressIndex}) {
+    return monero.Wallet_deviceShowAddress(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex);
+  }
+  
+  @override
+  String displayAmount(int amount) {
+    return monero.Wallet_displayAmount(amount);
+  }
+  
+  @override
+  String errorString() {
+    return monero.Wallet_errorString(walletPtr);
+  }
+  
+  @override
+  int estimateBlockChainHeight() {
+    return monero.Wallet_estimateBlockChainHeight(walletPtr);
+  }
+  
+  @override
+  String exchangeMultisigKeys({required List<String> info, required bool force_update_use_with_caution}) {
+    return monero.Wallet_exchangeMultisigKeys(walletPtr, info: info, force_update_use_with_caution: force_update_use_with_caution);
+  }
+  
+  @override
+  bool exportKeyImages(String filename, {required bool all}) {
+    return monero.Wallet_exportKeyImages(walletPtr, filename, all: all);
+  }
+  
+  @override
+  String exportKeyImagesUR({int max_fragment_length = 130, bool all = false}) {
+    return monero.Wallet_exportKeyImagesUR(walletPtr, max_fragment_length: max_fragment_length, all: all);
+  }
+  
+  @override
+  List<String> exportMultisigImages({required List<String> info}) {
+    return monero.Wallet_exportMultisigImages(walletPtr, info: info, force_update_use_with_caution: false);
+  }
+  
+  @override
+  bool exportOutputs(String filename, {required bool all}) {
+    return monero.Wallet_exportOutputs(walletPtr, filename, all: all);
+  }
+  
+  @override
+  String exportOutputsUR({int max_fragment_length = 130, bool all = false}) {
+    return monero.Wallet_exportOutputsUR(walletPtr, max_fragment_length: max_fragment_length, all: all);
+  }
+  
+  @override
+  String filename() {
+    return monero.Wallet_filename(walletPtr);
+  }
+  
+  @override
+  String genPaymentId() {
+    return monero.Wallet_genPaymentId();
+  }
+  
+  @override
+  int getBackgroundSyncType() {
+    return monero.Wallet_getBackgroundSyncType(walletPtr);
+  }
+  
+  @override
+  int getBytesReceived() {
+    return monero.Wallet_getBytesReceived(walletPtr);
+  }
+  
+  @override
+  int getBytesSent() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  String getCacheAttribute({required String key}) {
+    return monero.Wallet_getCacheAttribute(walletPtr, key: key);
+  }
+  
+  @override
+  int getDeviceType() {
+    return monero.Wallet_getDeviceType(walletPtr);
+  }
+  
+  @override
+  String getMultisigInfo() {
+    return monero.Wallet_getMultisigInfo(walletPtr);
+  }
+  
+  @override
+  String getPassword() {
+    return monero.Wallet_getPassword(walletPtr);
+  }
+  
+  @override
+  String getPolyseed({required String passphrase}) {
+    return monero.Wallet_getPolyseed(walletPtr, passphrase: passphrase);
+  }
+  
+  @override
+  Pointer<UnsignedChar> getReceivedFromDevice() {
+    return monero.Wallet_getReceivedFromDevice(walletPtr);
+  }
+  
+  @override
+  int getReceivedFromDeviceLength() {
+    return monero.Wallet_getReceivedFromDeviceLength(walletPtr);
+  }
+  
+  @override
+  int getRefreshFromBlockHeight() {
+    return monero.Wallet_getRefreshFromBlockHeight(walletPtr);
+  }
+  
+  @override
+  String getSeedLanguage() {
+    return monero.Wallet_getSeedLanguage(walletPtr);
+  }
+  
+  @override
+  Pointer<UnsignedChar> getSendToDevice() {
+    return monero.Wallet_getSendToDevice(walletPtr);
+  }
+  
+  @override
+  int getSendToDeviceLength() {
+    return monero.Wallet_getSendToDeviceLength(walletPtr);
+  }
+  
+  @override
+  bool getStateIsConnected() {
+    return monero.Wallet_getStateIsConnected(walletPtr);
+  }
+  
+  @override
+  String getSubaddressLabel({required int accountIndex, required int addressIndex}) {
+    return monero.Wallet_getSubaddressLabel(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex);
+  }
+  
+  @override
+  String getTxKey({required String txid}) {
+    return monero.Wallet_getTxKey(walletPtr, txid: txid);
+  }
+  
+  @override
+  String getUserNote({required String txid}) {
+    return monero.Wallet_getUserNote(walletPtr, txid: txid);
+  }
+  
+  @override
+  bool getWaitsForDeviceReceive() {
+    return monero.Wallet_getWaitsForDeviceReceive(walletPtr);
+  }
+  
+  @override
+  bool getWaitsForDeviceSend() {
+    return monero.Wallet_getWaitsForDeviceSend(walletPtr);
+  }
+  
+  @override
+  Wallet2WalletListener getWalletListener() {
+    final listener = monero.MONERO_cw_getWalletListener(walletPtr);
+    return MoneroWalletListener(listener);
+  }
+  
+  @override
+  int hasMultisigPartialKeyImages() {
+    return monero.Wallet_hasMultisigPartialKeyImages(walletPtr);
+  }
+  
+  @override
+  bool hasUnknownKeyImages() {
+    return monero.Wallet_hasUnknownKeyImages(walletPtr);
+  }
+  
+  @override
+  Wallet2TransactionHistory history() {
+    return MoneroTransactionHistory(monero.Wallet_history(walletPtr));
+  }
+  
+  @override
+  bool importKeyImages(String filename) {
+    return monero.Wallet_importKeyImages(walletPtr, filename);
+  }
+  
+  @override
+  bool importKeyImagesUR(String input) {
+    return monero.Wallet_importKeyImagesUR(walletPtr, input);
+  }
+  
+  @override
+  int importMultisigImages({required List<String> info}) {
+    return monero.Wallet_importMultisigImages(walletPtr, info: info);
+  }
+  
+  @override
+  bool importOutputs(String filename) {
+    return monero.Wallet_importOutputs(walletPtr, filename);
+  }
+  
+  @override
+  bool importOutputsUR(String input) {
+    return monero.Wallet_importOutputsUR(walletPtr, input);
+  }
+  
+  @override
+  bool init({required String daemonAddress, int upperTransacationSizeLimit = 0, String daemonUsername = "", String daemonPassword = "", bool useSsl = false, bool lightWallet = false, String proxyAddress = ""}) {
+    return monero.Wallet_init(walletPtr, daemonAddress: daemonAddress, upperTransacationSizeLimit: upperTransacationSizeLimit, daemonUsername: daemonUsername, daemonPassword: daemonPassword, useSsl: useSsl, lightWallet: lightWallet, proxyAddress: proxyAddress);
+  }
+  
+  @override
+  void init3({required String argv0, required String defaultLogBaseName, required String logPath, required bool console}) {
+    return monero.Wallet_init3(walletPtr, argv0: argv0, defaultLogBaseName: defaultLogBaseName, logPath: logPath, console: console);
+  }
+  
+  @override
+  String integratedAddress({required String paymentId}) {
+    return monero.Wallet_integratedAddress(walletPtr, paymentId: paymentId);
+  }
+  
+  @override
+  bool isBackgroundSyncing() {
+    return monero.Wallet_isBackgroundSyncing(walletPtr);
+  }
+  
+  @override
+  bool isBackgroundWallet() {
+    return monero.Wallet_isBackgroundWallet(walletPtr);
+  }
+  
+  @override
+  bool isKeysFileLocked() {
+    return monero.Wallet_isKeysFileLocked(walletPtr);
+  }
+  
+  @override
+  bool isOffline() {
+    return monero.Wallet_isOffline(walletPtr);
+  }
+  
+  @override
+  void keyReuseMitigation2({required bool mitigation}) {
+    monero.Wallet_keyReuseMitigation2(walletPtr, mitigation: mitigation);
+  }
+  
+  @override
+  bool keyValid({required String secret_key_string, required String address_string, required bool isViewKey, required int nettype}) {
+    return monero.Wallet_keyValid(secret_key_string: secret_key_string, address_string: address_string, isViewKey: isViewKey, nettype: nettype);
+  }
+  
+  @override
+  String keyValid_error({required String secret_key_string, required String address_string, required bool isViewKey, required int nettype}) {
+    return monero.Wallet_keyValid_error(secret_key_string: secret_key_string, address_string: address_string, isViewKey: isViewKey, nettype: nettype);
+  }
+  
+  @override
+  String keysFilename() {
+    return monero.Wallet_keysFilename(walletPtr);
+  }
+  
+  @override
+  Wallet2UnsignedTransaction loadUnsignedTx({required String unsigned_filename}) {
+    final tx = monero.Wallet_loadUnsignedTx(walletPtr, unsigned_filename: unsigned_filename);
+    return MoneroUnsignedTransaction(tx);
+  }
+  
+  @override
+  Wallet2UnsignedTransaction loadUnsignedTxUR({required String input}) {
+    final tx = monero.Wallet_loadUnsignedTxUR(walletPtr, input: input);
+    return MoneroUnsignedTransaction(tx);
+  }
+  
+  @override
+  bool lockKeysFile() {
+    return monero.Wallet_lockKeysFile(walletPtr);
+  }
+  
+  @override
+  String makeMultisig({required List<String> info, required int threshold}) {
+    return monero.Wallet_makeMultisig(walletPtr, info: info, threshold: threshold);
+  }
+  
+  @override
+  int maximumAllowedAmount() {
+    return monero.Wallet_maximumAllowedAmount();
+  }
+  
+  @override
+  Wallet2MultisigState multisig() {
+    return MoneroMultisigState(monero.Wallet_multisig(walletPtr));
+  }
+  
+  @override
+  int nettype() {
+    return monero.Wallet_nettype(walletPtr);
+  }
+  
+  @override
+  int numSubaddressAccounts() {
+    return monero.Wallet_numSubaddressAccounts(walletPtr);
+  }
+  
+  @override
+  int numSubaddresses({required int accountIndex}) {
+    return monero.Wallet_numSubaddresses(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  String path() {
+    return monero.Wallet_path(walletPtr);
+  }
+  
+  @override
+  void pauseRefresh() {
+    monero.Wallet_pauseRefresh(walletPtr);
+  }
+  
+  @override
+  String paymentIdFromAddress({required String strarg, required int nettype}) {
+    return monero.Wallet_paymentIdFromAddress(nettype: nettype, strarg: strarg);
+  }
+  
+  @override
+  bool paymentIdValid(String paymentId) {
+    return monero.Wallet_paymentIdValid(paymentId);
+  }
+  
+  @override
+  String publicMultisigSignerKey() {
+    return monero.Wallet_publicMultisigSignerKey(walletPtr);
+  }
+  
+  @override
+  String publicSpendKey() {
+    return monero.Wallet_publicSpendKey(walletPtr);
+  }
+  
+  @override
+  String publicViewKey() {
+    return monero.Wallet_publicViewKey(walletPtr);
+  }
+  
+  @override
+  bool reconnectDevice() {
+    return monero.Wallet_reconnectDevice(walletPtr);
+  }
+  
+  @override
+  bool refresh() {
+    return monero.Wallet_refresh(walletPtr);
+  }
+  
+  @override
+  void refreshAsync() {
+    monero.Wallet_refreshAsync(walletPtr);
+  }
+  
+  @override
+  bool rescanBlockchain() {
+    return monero.Wallet_rescanBlockchain(walletPtr);
+  }
+  
+  @override
+  void rescanBlockchainAsync() {
+    monero.Wallet_rescanBlockchainAsync(walletPtr);
+  }
+  
+  @override
+  bool rescanSpent() {
+    return monero.Wallet_rescanSpent(walletPtr);
+  }
+  
+  @override
+  Wallet2PendingTransaction restoreMultisigTransaction({required String signData}) {
+    final tx = monero.Wallet_restoreMultisigTransaction(walletPtr, signData: signData);
+    return MoneroPendingTransaction(tx);
+  }
+  
+  @override
+  String secretSpendKey() {
+    return monero.Wallet_secretSpendKey(walletPtr);
+  }
+  
+  @override
+  String secretViewKey() {
+    return monero.Wallet_secretViewKey(walletPtr);
+  }
+  
+  @override
+  String seed({required String seedOffset}) {
+    return monero.Wallet_seed(walletPtr, seedOffset: seedOffset);
+  }
+  
+  @override
+  void segregatePreForkOutputs({required bool segregate}) {
+    monero.Wallet_segregatePreForkOutputs(walletPtr, segregate: segregate);
+  }
+  
+  @override
+  void segregationHeight({required int height}) {
+    monero.Wallet_segregationHeight(walletPtr, height: height);
+  }
+  
+  @override
+  void setAutoRefreshInterval({required int millis}) {
+    monero.Wallet_setAutoRefreshInterval(walletPtr, millis: millis);
+  }
+  
+  @override
+  bool setCacheAttribute({required String key, required String value}) {
+    return monero.Wallet_setCacheAttribute(walletPtr, key: key, value: value);
+  }
+  
+  @override
+  void setDefaultMixin(int arg) {
+    monero.Wallet_setDefaultMixin(walletPtr, arg);
+  }
+  
+  @override
+  bool setDevicePin({required String passphrase}) {
+    return monero.Wallet_setDevicePin(walletPtr, passphrase: passphrase);
+  }
+  
+  @override
+  void setDeviceReceivedData(Pointer<UnsignedChar> data, int len) {
+    monero.Wallet_setDeviceReceivedData(walletPtr, data, len);
+  }
+  
+  @override
+  void setDeviceSendData(Pointer<UnsignedChar> data, int len) {
+    monero.Wallet_setDeviceSendData(walletPtr, data, len);
+  }
+  
+  @override
+  void setOffline({required bool offline}) {
+    monero.Wallet_setOffline(walletPtr, offline: offline);
+  }
+  
+  @override
+  bool setPassword({required String password}) {
+    return monero.Wallet_setPassword(walletPtr, password: password);
+  }
+  
+  @override
+  void setProxy({required String address}) {
+    monero.Wallet_setProxy(walletPtr, address: address);
+  }
+  
+  @override
+  void setRecoveringFromDevice({required bool recoveringFromDevice}) {
+    monero.Wallet_setRecoveringFromDevice(walletPtr, recoveringFromDevice: recoveringFromDevice);
+  }
+  
+  @override
+  void setRecoveringFromSeed({required bool recoveringFromSeed}) {
+    monero.Wallet_setRecoveringFromSeed(walletPtr, recoveringFromSeed: recoveringFromSeed);
+  }
+  
+  @override
+  void setRefreshFromBlockHeight({required int refresh_from_block_height}) {
+    monero.Wallet_setRefreshFromBlockHeight(walletPtr, refresh_from_block_height: refresh_from_block_height);
+  }
+  
+  @override
+  void setSeedLanguage({required String language}) {
+    monero.Wallet_setSeedLanguage(walletPtr, language: language);
+  }
+  
+  @override
+  void setSubaddressLabel({required int accountIndex, required int addressIndex, required String label}) {
+    monero.Wallet_setSubaddressLabel(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex, label: label);
+  }
+  
+  @override
+  void setSubaddressLookahead({required int major, required int minor}) {
+    monero.Wallet_setSubaddressLookahead(walletPtr, major: major, minor: minor);
+  }
+  
+  @override
+  void setTrustedDaemon({required bool arg}) {
+    monero.Wallet_setTrustedDaemon(walletPtr, arg: arg);
+  }
+  
+  @override
+  bool setUserNote({required String txid, required String note}) {
+    return monero.Wallet_setUserNote(walletPtr, txid: txid, note: note);
+  }
+  
+  @override
+  bool setupBackgroundSync({required int backgroundSyncType, required String walletPassword, required String backgroundCachePassword}) {
+    return monero.Wallet_setupBackgroundSync(walletPtr, backgroundSyncType: backgroundSyncType, walletPassword: walletPassword, backgroundCachePassword: backgroundCachePassword);
+  }
+  
+  @override
+  String signMessage({required String message, required String address}) {
+    return monero.Wallet_signMessage(walletPtr, message: message, address: address);
+  }
+  
+  @override
+  bool startBackgroundSync() {
+    return monero.Wallet_startBackgroundSync(walletPtr);
+  }
+  
+  @override
+  void startRefresh() {
+    monero.Wallet_startRefresh(walletPtr);
+  }
+  
+  @override
+  int status() {
+    return monero.Wallet_status(walletPtr);
+  }
+  
+  @override
+  void stop() {
+    monero.Wallet_stop(walletPtr);
+  }
+  
+  @override
+  bool stopBackgroundSync(String walletPassword) {
+    return monero.Wallet_stopBackgroundSync(walletPtr, walletPassword);
+  }
+  
+  @override
+  bool store({String path = ""}) {
+    return monero.Wallet_store(walletPtr, path: path);
+  }
+  
+  @override
+  Wallet2Subaddress subaddress() {
+    return MoneroSubaddress(monero.Wallet_subaddress(walletPtr));
+  }
+  
+  @override
+  Wallet2SubaddressAccount subaddressAccount() {
+    return MoneroSubaddressAccount(monero.Wallet_subaddressAccount(walletPtr));
+  }
+  
+  @override
+  bool submitTransaction(String filename) {
+    return monero.Wallet_submitTransaction(walletPtr, filename);
+  }
+  
+  @override
+  bool submitTransactionUR(String input) {
+    return monero.Wallet_submitTransactionUR(walletPtr, input);
+  }
+  
+  @override
+  bool synchronized() {
+    return monero.Wallet_synchronized(walletPtr);
+  }
+  
+  @override
+  bool trustedDaemon() {
+    return monero.Wallet_trustedDaemon(walletPtr);
+  }
+  
+  @override
+  bool unlockKeysFile() {
+    return monero.Wallet_unlockKeysFile(walletPtr);
+  }
+  
+  @override
+  int unlockedBalance({required int accountIndex}) {
+    return monero.Wallet_unlockedBalance(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  int useForkRules({required int version, required int earlyBlocks}) {
+    return monero.Wallet_useForkRules(walletPtr, version: version, earlyBlocks: earlyBlocks);
+  }
+  
+  @override
+  bool verifySignedMessage({required String message, required String address, required String signature}) {
+    return monero.Wallet_verifySignedMessage(walletPtr, message: message, address: address, signature: signature);
+  }
+  
+  @override
+  int viewOnlyBalance({required int accountIndex}) {
+    return monero.Wallet_viewOnlyBalance(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  bool watchOnly() {
+    return monero.Wallet_watchOnly(walletPtr);
+  }
+}
+
+class MoneroWalletManager implements Wallet2WalletManager {
+  MoneroWalletManager(this.wmPtr);
+
+  final monero.WalletManager wmPtr;
+  
+  @override
+  Future<int> blockTarget() async {
+    return monero.WalletManager_blockTarget(wmPtr);
+  }
+  
+  @override
+  Future<int> blockchainHeight() async {
+    return monero.WalletManager_blockchainHeight(wmPtr);
+  }
+  
+  @override
+  Future<int> blockchainTargetHeight() async {
+    return monero.WalletManager_blockchainTargetHeight(wmPtr);
+  }
+  
+  @override
+  Wallet2Wallet createDeterministicWalletFromSpendKey({required String path, required String password, String language = "English", int networkType = 0, required String spendKeyString, required bool newWallet, required int restoreHeight, int kdfRounds = 1}) {
+    final wallet = monero.WalletManager_createDeterministicWalletFromSpendKey(wmPtr, path: path, password: password, language: language, networkType: networkType, spendKeyString: spendKeyString, newWallet: newWallet, restoreHeight: restoreHeight, kdfRounds: kdfRounds);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWallet({required String path, required String password, String language = "English", int networkType = 0}) {
+    final wallet = monero.WalletManager_createWallet(wmPtr, path: path, password: password, language: language, networkType: networkType);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWalletFromDevice({required String path, required String password, int networkType = 0, required String deviceName, int restoreHeight = 0, String subaddressLookahead = "", int kdfRounds = 1}) {
+    final wallet = monero.WalletManager_createWalletFromDevice(wmPtr, path: path, password: password, deviceName: deviceName, restoreHeight: restoreHeight, subaddressLookahead: subaddressLookahead, kdfRounds: kdfRounds);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWalletFromKeys({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}) {
+    final wallet = monero.WalletManager_createWalletFromKeys(wmPtr, path: path, password: password, language: language, nettype: nettype, restoreHeight: restoreHeight, addressString: addressString, viewKeyString: viewKeyString, spendKeyString: spendKeyString);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWalletFromPolyseed({required String path, required String password, int networkType = 0, required String mnemonic, required String seedOffset, required bool newWallet, required int restoreHeight, required int kdfRounds}) {
+    final wallet = monero.WalletManager_createWalletFromPolyseed(wmPtr, path: path, password: password, networkType: networkType, mnemonic: mnemonic, seedOffset: seedOffset, newWallet: newWallet, restoreHeight: restoreHeight, kdfRounds: kdfRounds);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  String errorString() {
+    return monero.WalletManager_errorString(wmPtr);
+  }
+  
+  @override
+  List<String> findWallets({required String path}) {
+    return monero.WalletManager_findWallets(wmPtr, path: path);
+  }
+  
+  @override
+  bool isMining() {
+    return monero.WalletManager_isMining(wmPtr);
+  }
+  
+  @override
+  double miningHashRate() {
+    return monero.WalletManager_miningHashRate(wmPtr);
+  }
+  
+  @override
+  int networkDifficulty() {
+    return monero.WalletManager_networkDifficulty(wmPtr);
+  }
+  
+  @override
+  Wallet2Wallet openWallet({required String path, required String password, int networkType = 0}) {
+    final wallet = monero.WalletManager_openWallet(wmPtr, path: path, password: password, networkType: networkType);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  int queryWalletDevice({required String keysFileName, required String password, required int kdfRounds}) {
+    return monero.WalletManager_queryWalletDevice(wmPtr, keysFileName: keysFileName, password: password, kdfRounds: kdfRounds);
+  }
+  
+  @override
+  Wallet2Wallet recoveryWallet({required String path, required String password, required String mnemonic, int networkType = 0, required int restoreHeight, int kdfRounds = 0, required String seedOffset}) {
+    final wallet = monero.WalletManager_recoveryWallet(wmPtr, path: path, password: password, mnemonic: mnemonic, networkType: networkType, restoreHeight: restoreHeight, kdfRounds: kdfRounds, seedOffset: seedOffset);
+    return MoneroWallet(wallet);
+  }
+  
+  @override
+  String resolveOpenAlias({required String address, required bool dnssecValid}) {
+    return monero.WalletManager_resolveOpenAlias(wmPtr, address: address, dnssecValid: dnssecValid);
+  }
+  
+  @override
+  void setDaemonAddress(String address) {
+    monero.WalletManager_setDaemonAddress(wmPtr, address);
+  }
+  
+  @override
+  bool setProxy(String address) {
+    return monero.WalletManager_setProxy(wmPtr, address);
+  }
+  
+  @override
+  bool startMining({required String address, required int threads, required bool backgroundMining, required bool ignoreBattery}) {
+    return monero.WalletManager_startMining(wmPtr, address: address, threads: threads, backgroundMining: backgroundMining, ignoreBattery: ignoreBattery);
+  }
+  
+  @override
+  bool stopMining(String address) {
+    return monero.WalletManager_stopMining(wmPtr, address);
+  }
+  
+  @override
+  bool verifyWalletPassword({required String keysFileName, required String password, required bool noSpendKey, required int kdfRounds}) {
+    return monero.WalletManager_verifyWalletPassword(wmPtr, keysFileName: keysFileName, password: password, noSpendKey: noSpendKey, kdfRounds: kdfRounds);
+  }
+  
+  @override
+  bool walletExists(String path) {
+    return monero.WalletManager_walletExists(wmPtr, path);
+  }
+}
+
+class MoneroWalletManagerFactory implements Wallet2WalletManagerFactory {
+  @override
+  Wallet2WalletManager getWalletManager() {
+    return MoneroWalletManager(monero.WalletManagerFactory_getWalletManager());
+  }
+
+  @override
+  void setLogCategories(String categories) {
+    monero.WalletManagerFactory_setLogCategories(categories);
+  }
+
+  @override
+  void setLogLevel(int level) {
+    monero.WalletManagerFactory_setLogLevel(level);
+  }
+}
diff --git a/impls/monero.dart/lib/src/wallet2.dart b/impls/monero.dart/lib/src/wallet2.dart
new file mode 100644
index 0000000..4b87c6a
--- /dev/null
+++ b/impls/monero.dart/lib/src/wallet2.dart
@@ -0,0 +1,372 @@
+// ignore_for_file: non_constant_identifier_names
+
+import 'dart:ffi';
+import 'dart:io';
+abstract class Wallet2 {
+  Wallet2WalletManagerFactory walletManagerFactory();
+ 
+  static String get libPath {
+    if (Platform.isWindows) return 'unknown_libwallet2_api_c.dll';
+    if (Platform.isMacOS) return 'unknown_libwallet2_api_c.dylib';
+    if (Platform.isIOS) return 'UnknownWallet.framework/UnknownWallet';
+    if (Platform.isAndroid) return 'libunknown_libwallet2_api_c.so';
+    return 'unknown_libwallet2_api_c.so';
+  }
+  static set libPath(String path) {
+    throw Exception('libPath is read-only, as isolates cannot be made aware of changes to this variable');
+  }
+}
+
+abstract class Wallet2AddressBook {
+  int getAll_size();
+  Wallet2AddressBookRow getAll_byIndex(int index);
+  bool addRow({required String dstAddr, required String paymentId, required String description, });
+  bool deleteRow({required int rowId});
+  bool setDescription({required int rowId, required String description, });
+  void refresh();
+  int errorCode();
+  int lookupPaymentID({required String paymentId});
+}
+
+abstract class Wallet2AddressBookRow {
+  String extra();
+  String getAddress();
+  String getDescription();
+  String getPaymentId();
+  int getRowId();
+}
+
+abstract class Wallet2Coins {
+  int count();
+  Wallet2CoinsInfo coin(int index);
+  int getAll_size();
+  Wallet2CoinsInfo getAll_byIndex(int index);
+  void refresh();
+  void setFrozenByPublicKey({required String publicKey});
+  void setFrozen({required int index});
+  void thaw({required int index});
+  void thawByPublicKey({required String publicKey});
+  bool isTransferUnlocked({required int unlockTime, required int blockHeight});
+}
+
+abstract class Wallet2CoinsInfo {
+  int blockHeight();
+  String hash();
+  int internalOutputIndex();
+  int globalOutputIndex();
+  bool spent();
+  bool frozen();
+  int spentHeight();
+  int amount();
+  bool rct();
+  bool keyImageKnown();
+  int pkIndex();
+  int subaddrIndex();
+  int subaddrAccount();
+  String address();
+  String addressLabel();
+  String keyImage();
+  int unlockTime();
+  bool unlocked();
+  String pubKey();
+  bool coinbase();
+  String description();
+}
+
+abstract class Wallet2DeviceProgress {
+  bool progress();
+  bool indeterminate();
+}
+
+abstract class Wallet2WalletListener {
+  void resetNeedToRefresh();
+  bool isNeedToRefresh();
+  bool isNewTransactionExist();
+  void resetIsNewTransactionExist();
+  int height();
+}
+
+abstract class Wallet2Checksum {
+  String checksum_wallet2_api_c_h();
+  String checksum_wallet2_api_c_cpp();
+  String checksum_wallet2_api_c_exp();
+}
+
+abstract class Wallet2Free {
+  void free(Pointer<Void> wlptr);
+}
+
+abstract class Wallet2MultisigState {
+  bool isMultisig(Pointer<Void> ptr);
+  bool isReady(Pointer<Void> ptr);
+  int threshold(Pointer<Void> ptr);
+  int total(Pointer<Void> ptr);
+}
+
+abstract class Wallet2PendingTransaction {
+  int status();
+  String errorString();
+  bool commit({required String filename, required bool overwrite});
+  String commitUR(int max_fragment_length);
+  int amount();
+  int dust();
+  int fee();
+  String txid(String separator);
+  int txCount();
+  String subaddrAccount(String separator);
+  String subaddrIndices(String separator);
+  String multisigSignData();
+  void signMultisigTx();
+  String signersKeys(String separator);
+  String hex(String separator);
+}
+
+abstract class Wallet2Subaddress {
+  int getAll_size();
+  Wallet2SubaddressRow getAll_byIndex(int index);
+  void addRow({required int accountIndex, required String label});
+  void setLabel({required int accountIndex, required int addressIndex, required String label});
+  void refresh({required int accountIndex, required String label});
+}
+
+abstract class Wallet2SubaddressAccount {
+  int getAll_size();
+  Wallet2SubaddressAccountRow getAll_byIndex(int index);
+  void addRow({required String label});
+  void setLabel({required int accountIndex, required String label});
+  void refresh();
+}
+
+abstract class Wallet2SubaddressAccountRow {
+  String extra();
+  String getAddress();
+  String getLabel();
+  String getBalance();
+  String getUnlockedBalance();
+  int getRowId();
+}
+
+abstract class Wallet2SubaddressRow {
+  String extra();
+  String getAddress();
+  String getLabel();
+  int getRowId();
+}
+
+abstract class Wallet2TransactionHistory {
+  int count();
+  Wallet2TransactionInfo transaction(int index);
+  Wallet2TransactionInfo transactionById(String txid);
+  void refresh();
+  void setTxNote({required String txid, required String note});
+}
+
+abstract class Wallet2TransactionInfo {
+  int direction();
+  bool isPending();
+  bool isFailed();
+  bool isCoinbase();
+  int amount();
+  int fee();
+  int blockHeight();
+  String description();
+  String subaddrIndex();
+  int subaddrAccount();
+  String label();
+  int confirmations();
+  int unlockTime();
+  String hash();
+  int timestamp();
+  String paymentId();
+  int transfers_count();
+  int transfers_amount(int index);
+  String transfers_address(int index);
+}
+
+abstract class Wallet2UnsignedTransaction {
+  int status();
+  String errorString();
+  String amount();
+  String fee();
+  String mixin();
+  String confirmationMessage();
+  String paymentId();
+  String recipientAddress();
+  int minMixinCount();
+  int txCount();
+  bool sign(String signedFileName);
+  String signUR(int max_fragment_length);
+}
+
+abstract class Wallet2Wallet {
+  String seed({required String seedOffset});
+  String getSeedLanguage();
+  void setSeedLanguage({required String language});
+  int status();
+  String errorString();
+  bool setPassword({required String password});
+  String getPassword();
+  bool setDevicePin({required String passphrase});
+  String address({int accountIndex = 0, int addressIndex = 0});
+  String path();
+  int nettype();
+  int useForkRules({required int version, required int earlyBlocks, });
+  String integratedAddress({required String paymentId});
+  String secretViewKey();
+  String publicViewKey();
+  String secretSpendKey();
+  String publicSpendKey();
+  String publicMultisigSignerKey();
+  void stop();
+  bool store({String path = ""});
+  String filename();
+  String keysFilename();
+  bool init({ required String daemonAddress, int upperTransacationSizeLimit = 0, String daemonUsername = "", String daemonPassword = "", bool useSsl = false, bool lightWallet = false, String proxyAddress = "", });
+  bool createWatchOnly({ required String path, required String password, required String language, });
+  void setRefreshFromBlockHeight({required int refresh_from_block_height});
+  int getRefreshFromBlockHeight();
+  void setRecoveringFromSeed({required bool recoveringFromSeed});
+  void setRecoveringFromDevice({required bool recoveringFromDevice});
+  void setSubaddressLookahead({required int major, required int minor});
+  bool connectToDaemon();
+  int connected();
+  void setTrustedDaemon({required bool arg});
+  bool trustedDaemon();
+  void setProxy({required String address});
+  int balance({required int accountIndex});
+  int unlockedBalance({required int accountIndex});
+  int viewOnlyBalance({required int accountIndex});
+  bool watchOnly();
+  int blockChainHeight();
+  int approximateBlockChainHeight();
+  int estimateBlockChainHeight();
+  int daemonBlockChainHeight();
+  bool synchronized();
+  String displayAmount(int amount);
+  int amountFromString(String amount);
+  int amountFromDouble(double amount);
+  String genPaymentId();
+  bool paymentIdValid(String paymentId);
+  bool addressValid(String address, int networkType);
+  bool keyValid({required String secret_key_string, required String address_string, required bool isViewKey, required int nettype});
+  String keyValid_error({required String secret_key_string, required String address_string, required bool isViewKey, required int nettype});
+  String paymentIdFromAddress({required String strarg, required int nettype});
+  int maximumAllowedAmount();
+  void init3({ required String argv0, required String defaultLogBaseName, required String logPath, required bool console, });
+  String getPolyseed({required String passphrase});
+  String createPolyseed({ String language = "English", });
+  void startRefresh();
+  void pauseRefresh();
+  bool refresh();
+  void refreshAsync();
+  bool rescanBlockchain();
+  void rescanBlockchainAsync();
+  void setAutoRefreshInterval({required int millis});
+  int autoRefreshInterval();
+  void addSubaddress({required int accountIndex, String label = ""});
+  void addSubaddressAccount({String label = ""});
+  int numSubaddressAccounts();
+  int numSubaddresses({required int accountIndex});
+  String getSubaddressLabel({required int accountIndex, required int addressIndex});
+  void setSubaddressLabel({required int accountIndex, required int addressIndex, required String label});
+  Wallet2MultisigState multisig();
+  String getMultisigInfo();
+  String makeMultisig({ required List<String> info, required int threshold, });
+  String exchangeMultisigKeys({ required List<String> info, required bool force_update_use_with_caution, });
+  List<String> exportMultisigImages({ required List<String> info, });
+  int importMultisigImages({ required List<String> info, });
+  int hasMultisigPartialKeyImages();
+  Wallet2PendingTransaction restoreMultisigTransaction({ required String signData, });
+  Wallet2PendingTransaction createTransactionMultDest({ 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 [], });
+  Wallet2PendingTransaction createTransaction({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 [],});
+  Wallet2UnsignedTransaction loadUnsignedTx({required String unsigned_filename});
+  Wallet2UnsignedTransaction loadUnsignedTxUR({required String input});
+  bool submitTransaction(String filename);
+  bool submitTransactionUR(String input);
+  bool hasUnknownKeyImages();
+  bool exportKeyImages(String filename, {required bool all});
+  String exportKeyImagesUR({ int max_fragment_length = 130, bool all = false, });
+  bool importKeyImages(String filename);
+  bool importKeyImagesUR(String input);
+  bool exportOutputs(String filename, {required bool all});
+  String exportOutputsUR({ int max_fragment_length = 130, bool all = false, });
+  bool importOutputs(String filename);
+  bool importOutputsUR(String input);
+  bool setupBackgroundSync({ required int backgroundSyncType, required String walletPassword, required String backgroundCachePassword, });
+  int getBackgroundSyncType();
+  bool startBackgroundSync();
+  bool stopBackgroundSync(String walletPassword);
+  bool isBackgroundSyncing();
+  bool isBackgroundWallet();
+  Wallet2TransactionHistory history();
+  Wallet2AddressBook addressBook();
+  Wallet2Coins coins();
+  Wallet2Subaddress subaddress();
+  Wallet2SubaddressAccount subaddressAccount();
+  int defaultMixin();
+  void setDefaultMixin(int arg);
+  bool setCacheAttribute({required String key, required String value});
+  String getCacheAttribute({required String key});
+  bool setUserNote({required String txid, required String note});
+  String getUserNote({required String txid});
+  String getTxKey({required String txid});
+  String signMessage({ required String message, required String address, });
+  bool verifySignedMessage({ required String message, required String address, required String signature, });
+  bool rescanSpent();
+  void setOffline({required bool offline});
+  bool isOffline();
+  void segregatePreForkOutputs({required bool segregate});
+  void segregationHeight({required int height});
+  void keyReuseMitigation2({required bool mitigation});
+  bool lockKeysFile();
+  bool unlockKeysFile();
+  bool isKeysFileLocked();
+  int getDeviceType();
+  int coldKeyImageSync({required int spent, required int unspent});
+  String deviceShowAddress({required int accountIndex, required int addressIndex});
+  bool reconnectDevice();
+  int getBytesReceived();
+  bool getStateIsConnected();
+  Pointer<UnsignedChar> getSendToDevice();
+  int getSendToDeviceLength();
+  Pointer<UnsignedChar> getReceivedFromDevice();
+  int getReceivedFromDeviceLength();
+  bool getWaitsForDeviceSend();
+  bool getWaitsForDeviceReceive();
+  void setDeviceReceivedData(Pointer<UnsignedChar> data, int len);
+  void setDeviceSendData(Pointer<UnsignedChar> data, int len);
+  int getBytesSent();
+  Wallet2WalletListener getWalletListener();
+}
+
+abstract class Wallet2WalletManager {
+  Wallet2Wallet createWallet({ required String path, required String password, String language = "English", int networkType = 0, });
+  Wallet2Wallet openWallet({ required String path, required String password, int networkType = 0, });
+  Wallet2Wallet recoveryWallet({ required String path, required String password, required String mnemonic, int networkType = 0, required int restoreHeight, int kdfRounds = 0, required String seedOffset, });
+  Wallet2Wallet createWalletFromKeys({ 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, });
+  Wallet2Wallet createDeterministicWalletFromSpendKey({ required String path, required String password, String language = "English", int networkType = 0, required String spendKeyString, required bool newWallet, required int restoreHeight, int kdfRounds = 1, });
+  Wallet2Wallet createWalletFromDevice({ required String path, required String password, int networkType = 0, required String deviceName, int restoreHeight = 0, String subaddressLookahead = "", int kdfRounds = 1, });
+  Wallet2Wallet createWalletFromPolyseed({ required String path, required String password, int networkType = 0, required String mnemonic, required String seedOffset, required bool newWallet, required int restoreHeight, required int kdfRounds, });
+  bool walletExists(String path);
+  bool verifyWalletPassword({ required String keysFileName, required String password, required bool noSpendKey, required int kdfRounds, });
+  int queryWalletDevice({ required String keysFileName, required String password, required int kdfRounds, });
+  List<String> findWallets({required String path});
+  String errorString();
+  void setDaemonAddress(String address);
+  Future<int> blockchainHeight();
+  Future<int> blockchainTargetHeight();
+  int networkDifficulty();
+  double miningHashRate();
+  Future<int> blockTarget();
+  bool isMining();
+  bool startMining({ required String address, required int threads, required bool backgroundMining, required bool ignoreBattery, });
+  bool stopMining(String address);
+  String resolveOpenAlias({ required String address, required bool dnssecValid, });
+  bool setProxy(String address);
+}
+
+abstract class Wallet2WalletManagerFactory {
+  void setLogLevel(int level);
+  void setLogCategories(String categories);
+  Wallet2WalletManager getWalletManager();
+}
\ No newline at end of file
diff --git a/impls/monero.dart/lib/src/wownero.dart b/impls/monero.dart/lib/src/wownero.dart
new file mode 100644
index 0000000..7bf8809
--- /dev/null
+++ b/impls/monero.dart/lib/src/wownero.dart
@@ -0,0 +1,1616 @@
+// ignore_for_file: deprecated_member_use_from_same_package
+
+import 'dart:ffi';
+
+import 'package:monero/wownero.dart' as wownero;
+import 'package:monero/src/wallet2.dart';
+
+class Wownero implements Wallet2 {
+  @override
+  Wallet2WalletManagerFactory walletManagerFactory() {
+    return WowneroWalletManagerFactory();
+  }
+
+}
+
+class WowneroAddressBook implements Wallet2AddressBook {
+  WowneroAddressBook(this.addressBookPtr);
+
+  final wownero.AddressBook addressBookPtr;
+  
+  @override
+  bool addRow({required String dstAddr, required String paymentId, required String description}) {
+    return wownero.AddressBook_addRow(addressBookPtr, dstAddr: dstAddr, paymentId: paymentId, description: description);
+  }
+  
+  @override
+  bool deleteRow({required int rowId}) {
+    return wownero.AddressBook_deleteRow(addressBookPtr, rowId: rowId);
+  }
+  
+  @override
+  int errorCode() {
+    return wownero.AddressBook_errorCode(addressBookPtr);
+  }
+  
+  @override
+  Wallet2AddressBookRow getAll_byIndex(int index) {
+    final row = wownero.AddressBook_getAll_byIndex(addressBookPtr, index: index);
+    return WowneroAddressBookRow(row);
+  }
+  
+  @override
+  int getAll_size() {
+    return wownero.AddressBook_getAll_size(addressBookPtr);
+  }
+  
+  @override
+  int lookupPaymentID({required String paymentId}) {
+    return wownero.AddressBook_lookupPaymentID(addressBookPtr, paymentId: paymentId);
+  }
+  
+  @override
+  void refresh() {
+    wownero.AddressBook_refresh(addressBookPtr);
+  }
+  
+  @override
+  bool setDescription({required int rowId, required String description}) {
+    return wownero.AddressBook_setDescription(addressBookPtr, rowId: rowId, description: description);
+  }
+}
+
+class WowneroAddressBookRow implements Wallet2AddressBookRow {
+  WowneroAddressBookRow(this.addressBookRowPtr);
+
+  final wownero.AddressBookRow addressBookRowPtr;
+  
+  @override
+  String extra() {
+    return wownero.AddressBookRow_extra(addressBookRowPtr);
+  }
+  
+  @override
+  String getAddress() {
+    return wownero.AddressBookRow_getAddress(addressBookRowPtr);
+  }
+  
+  @override
+  String getDescription() {
+    return wownero.AddressBookRow_getDescription(addressBookRowPtr);
+  }
+  
+  @override
+  String getPaymentId() {
+    return wownero.AddressBookRow_getPaymentId(addressBookRowPtr);
+  }
+  
+  @override
+  int getRowId() {
+    return wownero.AddressBookRow_getRowId(addressBookRowPtr);
+  }
+}
+
+class WowneroCoins implements Wallet2Coins {
+  WowneroCoins(this.coinsPtr);
+
+  final wownero.Coins coinsPtr;
+  
+  @override
+  Wallet2CoinsInfo coin(int index) {
+    final coin = wownero.Coins_coin(coinsPtr, index);
+    return WowneroCoinsInfo(coin);
+  }
+  
+  @override
+  int count() {
+    return wownero.Coins_count(coinsPtr);
+  }
+  
+  @override
+  Wallet2CoinsInfo getAll_byIndex(int index) {
+    final coin = wownero.Coins_getAll_byIndex(coinsPtr, index);
+    return WowneroCoinsInfo(coin);
+  }
+  
+  @override
+  int getAll_size() {
+    return wownero.Coins_getAll_size(coinsPtr);
+  }
+  
+  @override
+  bool isTransferUnlocked({required int unlockTime, required int blockHeight}) {
+    return wownero.Coins_isTransferUnlocked(coinsPtr, unlockTime: unlockTime, blockHeight: blockHeight);
+  }
+  
+  @override
+  void refresh() {
+    wownero.Coins_refresh(coinsPtr);
+  }
+  
+  @override
+  void setFrozen({required int index}) {
+    wownero.Coins_setFrozen(coinsPtr, index: index);
+  }
+  
+  @override
+  void setFrozenByPublicKey({required String publicKey}) {
+    wownero.Coins_setFrozenByPublicKey(coinsPtr, publicKey: publicKey);
+  }
+  
+  @override
+  void thaw({required int index}) {
+    wownero.Coins_thaw(coinsPtr, index: index);
+  }
+  
+  @override
+  void thawByPublicKey({required String publicKey}) {
+    wownero.Coins_thawByPublicKey(coinsPtr, publicKey: publicKey);
+  }
+}
+
+class WowneroCoinsInfo implements Wallet2CoinsInfo {
+  WowneroCoinsInfo(this.coinsInfoPtr);
+
+  final wownero.CoinsInfo coinsInfoPtr;
+  
+  @override
+  String address() {
+    return wownero.CoinsInfo_address(coinsInfoPtr);
+  }
+  
+  @override
+  String addressLabel() {
+    return wownero.CoinsInfo_addressLabel(coinsInfoPtr);
+  }
+  
+  @override
+  int amount() {
+    return wownero.CoinsInfo_amount(coinsInfoPtr);
+  }
+  
+  @override
+  int blockHeight() {
+    return wownero.CoinsInfo_blockHeight(coinsInfoPtr);
+  }
+  
+  @override
+  bool coinbase() {
+    return wownero.CoinsInfo_coinbase(coinsInfoPtr);
+  }
+  
+  @override
+  String description() {
+    return wownero.CoinsInfo_description(coinsInfoPtr);
+  }
+  
+  @override
+  bool frozen() {
+    return wownero.CoinsInfo_frozen(coinsInfoPtr);
+  }
+  
+  @override
+  int globalOutputIndex() {
+    return wownero.CoinsInfo_globalOutputIndex(coinsInfoPtr);
+  }
+  
+  @override
+  String hash() {
+    return wownero.CoinsInfo_hash(coinsInfoPtr);
+  }
+  
+  @override
+  int internalOutputIndex() {
+    return wownero.CoinsInfo_internalOutputIndex(coinsInfoPtr);
+  }
+  
+  @override
+  String keyImage() {
+    return wownero.CoinsInfo_keyImage(coinsInfoPtr);
+  }
+  
+  @override
+  bool keyImageKnown() {
+    return wownero.CoinsInfo_keyImageKnown(coinsInfoPtr);
+  }
+  
+  @override
+  int pkIndex() {
+    return wownero.CoinsInfo_pkIndex(coinsInfoPtr);
+  }
+  
+  @override
+  String pubKey() {
+    return wownero.CoinsInfo_pubKey(coinsInfoPtr);
+  }
+  
+  @override
+  bool rct() {
+    return wownero.CoinsInfo_rct(coinsInfoPtr);
+  }
+  
+  @override
+  bool spent() {
+    return wownero.CoinsInfo_spent(coinsInfoPtr);
+  }
+  
+  @override
+  int spentHeight() {
+    return wownero.CoinsInfo_spentHeight(coinsInfoPtr);
+  }
+  
+  @override
+  int subaddrAccount() {
+    return wownero.CoinsInfo_subaddrAccount(coinsInfoPtr);
+  }
+  
+  @override
+  int subaddrIndex() {
+    return wownero.CoinsInfo_subaddrIndex(coinsInfoPtr);
+  }
+  
+  @override
+  int unlockTime() {
+    return wownero.CoinsInfo_unlockTime(coinsInfoPtr);
+  }
+  
+  @override
+  bool unlocked() {
+    return wownero.CoinsInfo_unlocked(coinsInfoPtr);
+  }
+}
+
+class WowneroDeviceProgress implements Wallet2DeviceProgress {
+  WowneroDeviceProgress(this.deviceProgressPtr);
+
+  final wownero.DeviceProgress deviceProgressPtr;
+  
+  @override
+  bool indeterminate() {
+    return wownero.DeviceProgress_indeterminate(deviceProgressPtr);
+  }
+  
+  @override
+  bool progress() {
+    return wownero.DeviceProgress_progress(deviceProgressPtr);
+  }
+}
+
+class WowneroWalletListener implements Wallet2WalletListener {
+  WowneroWalletListener(this.walletListenerPtr);
+
+  final wownero.WalletListener walletListenerPtr;
+  
+  @override
+  int height() {
+    return wownero.WOWNERO_cw_WalletListener_height(walletListenerPtr);
+  }
+  
+  @override
+  bool isNeedToRefresh() {
+    return wownero.WOWNERO_cw_WalletListener_isNeedToRefresh(walletListenerPtr);
+  }
+  
+  @override
+  bool isNewTransactionExist() {
+    return wownero.WOWNERO_cw_WalletListener_isNewTransactionExist(walletListenerPtr);
+  }
+  
+  @override
+  void resetIsNewTransactionExist() {
+    wownero.WOWNERO_cw_WalletListener_resetIsNewTransactionExist(walletListenerPtr);
+  }
+  
+  @override
+  void resetNeedToRefresh() {
+    wownero.WOWNERO_cw_WalletListener_resetNeedToRefresh(walletListenerPtr);
+  }
+}
+
+class WowneroWalletChecksum implements Wallet2Checksum {
+  WowneroWalletChecksum();
+
+  @override
+  String checksum_wallet2_api_c_cpp() {
+    return wownero.WOWNERO_checksum_wallet2_api_c_cpp();
+  }
+  
+  @override
+  String checksum_wallet2_api_c_exp() {
+    return wownero.WOWNERO_checksum_wallet2_api_c_exp();
+  }
+  
+  @override
+  String checksum_wallet2_api_c_h() {
+    return wownero.WOWNERO_checksum_wallet2_api_c_h();
+  }
+}
+
+class WowneroFree implements Wallet2Free {
+  WowneroFree();
+
+  @override
+  void free(Pointer<Void> ptr) {
+    wownero.WOWNERO_free(ptr);
+  }
+}
+
+class WowneroMultisigState implements Wallet2MultisigState {
+  WowneroMultisigState(this.multisigStatePtr);
+
+  final wownero.MultisigState multisigStatePtr;
+  
+  @override
+  bool isMultisig(Pointer<Void> ptr) {
+    return wownero.MultisigState_isMultisig(multisigStatePtr);
+  }
+  
+  @override
+  bool isReady(Pointer<Void> ptr) {
+    return wownero.MultisigState_isReady(multisigStatePtr);
+  }
+  
+  @override
+  int threshold(Pointer<Void> ptr) {
+    return wownero.MultisigState_threshold(multisigStatePtr);
+  }
+  
+  @override
+  int total(Pointer<Void> ptr) {
+    return wownero.MultisigState_total(multisigStatePtr);
+  }
+}
+
+class WowneroPendingTransaction implements Wallet2PendingTransaction {
+  WowneroPendingTransaction(this.pendingTransactionPtr);
+
+  final wownero.PendingTransaction pendingTransactionPtr;
+  
+  @override
+  int amount() {
+    return wownero.PendingTransaction_amount(pendingTransactionPtr);
+  }
+  
+  @override
+  bool commit({required String filename, required bool overwrite}) {
+    return wownero.PendingTransaction_commit(pendingTransactionPtr, filename: filename, overwrite: overwrite);
+  }
+  
+  @override
+  String commitUR(int max_fragment_length) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int dust() {
+    return wownero.PendingTransaction_dust(pendingTransactionPtr);
+  }
+  
+  @override
+  String errorString() {
+    return wownero.PendingTransaction_errorString(pendingTransactionPtr);
+  }
+  
+  @override
+  int fee() {
+    return wownero.PendingTransaction_fee(pendingTransactionPtr);
+  }
+  
+  @override
+  String hex(String separator) {
+    return wownero.PendingTransaction_hex(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  String multisigSignData() {
+    return wownero.PendingTransaction_multisigSignData(pendingTransactionPtr);
+  }
+  
+  @override
+  void signMultisigTx() {
+    wownero.PendingTransaction_signMultisigTx(pendingTransactionPtr);
+  }
+  
+  @override
+  String signersKeys(String separator) {
+    return wownero.PendingTransaction_signersKeys(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  int status() {
+    return wownero.PendingTransaction_status(pendingTransactionPtr);
+  }
+  
+  @override
+  String subaddrAccount(String separator) {
+    return wownero.PendingTransaction_subaddrAccount(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  String subaddrIndices(String separator) {
+    return wownero.PendingTransaction_subaddrIndices(pendingTransactionPtr, separator);
+  }
+  
+  @override
+  int txCount() {
+    return wownero.PendingTransaction_txCount(pendingTransactionPtr);
+  }
+  
+  @override
+  String txid(String separator) {
+    return wownero.PendingTransaction_txid(pendingTransactionPtr, separator);
+  }
+}
+
+class WowneroSubaddress implements Wallet2Subaddress {
+  WowneroSubaddress(this.subaddressPtr);
+
+  final wownero.Subaddress subaddressPtr;
+  
+  @override
+  void addRow({required int accountIndex, required String label}) {
+    wownero.Subaddress_addRow(subaddressPtr, accountIndex: accountIndex, label: label);
+  }
+  
+  @override
+  Wallet2SubaddressRow getAll_byIndex(int index) {
+    final row = wownero.Subaddress_getAll_byIndex(subaddressPtr, index: index);
+    return WowneroSubaddressRow(row);
+  }
+  
+  @override
+  int getAll_size() {
+    return wownero.Subaddress_getAll_size(subaddressPtr);
+  }
+  
+  @override
+  void refresh({required int accountIndex, required String label}) {
+    wownero.Subaddress_refresh(subaddressPtr, accountIndex: accountIndex, label: label);
+  }
+  
+  @override
+  void setLabel({required int accountIndex, required int addressIndex, required String label}) {
+    wownero.Subaddress_setLabel(subaddressPtr, accountIndex: accountIndex, addressIndex: addressIndex, label: label);
+  }
+}
+
+class WowneroSubaddressAccount implements Wallet2SubaddressAccount {
+  WowneroSubaddressAccount(this.subaddressAccountPtr);
+
+  final wownero.SubaddressAccount subaddressAccountPtr;
+  
+  @override
+  void addRow({required String label}) {
+    wownero.SubaddressAccount_addRow(subaddressAccountPtr, label: label);
+  }
+  
+  @override
+  Wallet2SubaddressAccountRow getAll_byIndex(int index) {
+    final row = wownero.SubaddressAccount_getAll_byIndex(subaddressAccountPtr, index: index);
+    return WowneroSubaddressAccountRow(row);
+  }
+  
+  @override
+  int getAll_size() {
+    return wownero.SubaddressAccount_getAll_size(subaddressAccountPtr);
+  }
+  
+  @override
+  void refresh() {
+    wownero.SubaddressAccount_refresh(subaddressAccountPtr);
+  }
+  
+  @override
+  void setLabel({required int accountIndex, required String label}) {
+    wownero.SubaddressAccount_setLabel(subaddressAccountPtr, accountIndex: accountIndex, label: label);
+  }
+}
+
+class WowneroSubaddressAccountRow implements Wallet2SubaddressAccountRow {
+  WowneroSubaddressAccountRow(this.subaddressAccountRowPtr);
+
+  final wownero.SubaddressAccountRow subaddressAccountRowPtr;
+  
+  @override
+  String extra() {
+    return wownero.SubaddressAccountRow_extra(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getAddress() {
+    return wownero.SubaddressAccountRow_getAddress(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getBalance() {
+    return wownero.SubaddressAccountRow_getBalance(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getLabel() {
+    return wownero.SubaddressAccountRow_getLabel(subaddressAccountRowPtr);
+  }
+  
+  @override
+  int getRowId() {
+    return wownero.SubaddressAccountRow_getRowId(subaddressAccountRowPtr);
+  }
+  
+  @override
+  String getUnlockedBalance() {
+    return wownero.SubaddressAccountRow_getUnlockedBalance(subaddressAccountRowPtr);
+  }
+}
+
+class WowneroSubaddressRow implements Wallet2SubaddressRow {
+  WowneroSubaddressRow(this.subaddressRowPtr);
+
+  final wownero.SubaddressRow subaddressRowPtr;
+  
+  @override
+  String extra() {
+    return wownero.SubaddressRow_extra(subaddressRowPtr);
+  }
+  
+  @override
+  String getAddress() {
+    return wownero.SubaddressRow_getAddress(subaddressRowPtr);
+  }
+  
+  @override
+  String getLabel() {
+    return wownero.SubaddressRow_getLabel(subaddressRowPtr);
+  }
+  
+  @override
+  int getRowId() {
+    return wownero.SubaddressRow_getRowId(subaddressRowPtr);
+  }
+}
+
+class WowneroTransactionHistory implements Wallet2TransactionHistory {
+  WowneroTransactionHistory(this.transactionHistoryPtr);
+
+  final wownero.TransactionHistory transactionHistoryPtr;
+  
+  @override
+  int count() {
+    return wownero.TransactionHistory_count(transactionHistoryPtr);
+  }
+  
+  @override
+  void refresh() {
+    wownero.TransactionHistory_refresh(transactionHistoryPtr);
+  }
+  
+  @override
+  void setTxNote({required String txid, required String note}) {
+    wownero.TransactionHistory_setTxNote(transactionHistoryPtr, txid: txid, note: note);
+  }
+  
+  @override
+  Wallet2TransactionInfo transaction(int index) {
+    final tx = wownero.TransactionHistory_transaction(transactionHistoryPtr, index: index);
+    return WowneroTransactionInfo(tx);
+  }
+  
+  @override
+  Wallet2TransactionInfo transactionById(String txid) {
+    final tx = wownero.TransactionHistory_transactionById(transactionHistoryPtr, txid: txid);
+    return WowneroTransactionInfo(tx);
+  }
+}
+
+class WowneroTransactionInfo implements Wallet2TransactionInfo {
+  WowneroTransactionInfo(this.transactionInfoPtr);
+
+  final wownero.TransactionInfo transactionInfoPtr;
+  
+  @override
+  int amount() {
+    return wownero.TransactionInfo_amount(transactionInfoPtr);
+  }
+  
+  @override
+  int blockHeight() {
+    return wownero.TransactionInfo_blockHeight(transactionInfoPtr);
+  }
+  
+  @override
+  int confirmations() {
+    return wownero.TransactionInfo_confirmations(transactionInfoPtr);
+  }
+  
+  @override
+  String description() {
+    return wownero.TransactionInfo_description(transactionInfoPtr);
+  }
+  
+  @override
+  int direction() {
+    return wownero.TransactionInfo_direction(transactionInfoPtr).index;
+  }
+  
+  @override
+  int fee() {
+    return wownero.TransactionInfo_fee(transactionInfoPtr);
+  }
+  
+  @override
+  String hash() {
+    return wownero.TransactionInfo_hash(transactionInfoPtr);
+  }
+  
+  @override
+  bool isCoinbase() {
+    return wownero.TransactionInfo_isCoinbase(transactionInfoPtr);
+  }
+  
+  @override
+  bool isFailed() {
+    return wownero.TransactionInfo_isFailed(transactionInfoPtr);
+  }
+  
+  @override
+  bool isPending() {
+    return wownero.TransactionInfo_isPending(transactionInfoPtr);
+  }
+  
+  @override
+  String label() {
+    return wownero.TransactionInfo_label(transactionInfoPtr);
+  }
+  
+  @override
+  String paymentId() {
+    return wownero.TransactionInfo_paymentId(transactionInfoPtr);
+  }
+  
+  @override
+  int subaddrAccount() {
+    return wownero.TransactionInfo_subaddrAccount(transactionInfoPtr);
+  }
+  
+  @override
+  String subaddrIndex() {
+    return wownero.TransactionInfo_subaddrIndex(transactionInfoPtr);
+  }
+  
+  @override
+  int timestamp() {
+    return wownero.TransactionInfo_timestamp(transactionInfoPtr);
+  }
+  
+  @override
+  String transfers_address(int index) {
+    return wownero.TransactionInfo_transfers_address(transactionInfoPtr, index);
+  }
+  
+  @override
+  int transfers_amount(int index) {
+    return wownero.TransactionInfo_transfers_amount(transactionInfoPtr, index);
+  }
+  
+  @override
+  int transfers_count() {
+    return wownero.TransactionInfo_transfers_count(transactionInfoPtr);
+  }
+  
+  @override
+  int unlockTime() {
+    return wownero.TransactionInfo_unlockTime(transactionInfoPtr);
+  }
+  
+}
+
+class WowneroUnsignedTransaction implements Wallet2UnsignedTransaction {
+  WowneroUnsignedTransaction(this.unsignedTransactionPtr);
+
+  final wownero.UnsignedTransaction unsignedTransactionPtr;
+  
+  @override
+  String amount() {
+    return wownero.UnsignedTransaction_amount(unsignedTransactionPtr);
+  }
+  
+  @override
+  String confirmationMessage() {
+    return wownero.UnsignedTransaction_confirmationMessage(unsignedTransactionPtr);
+  }
+  
+  @override
+  String errorString() {
+    return wownero.UnsignedTransaction_errorString(unsignedTransactionPtr);
+  }
+  
+  @override
+  String fee() {
+    return wownero.UnsignedTransaction_fee(unsignedTransactionPtr);
+  }
+  
+  @override
+  int minMixinCount() {
+    return wownero.UnsignedTransaction_minMixinCount(unsignedTransactionPtr);
+  }
+  
+  @override
+  String mixin() {
+    return wownero.UnsignedTransaction_mixin(unsignedTransactionPtr);
+  }
+  
+  @override
+  String paymentId() {
+    return wownero.UnsignedTransaction_paymentId(unsignedTransactionPtr);
+  }
+  
+  @override
+  String recipientAddress() {
+    return wownero.UnsignedTransaction_recipientAddress(unsignedTransactionPtr);
+  }
+  
+  @override
+  bool sign(String signedFileName) {
+    return wownero.UnsignedTransaction_sign(unsignedTransactionPtr, signedFileName);
+  }
+  
+  @override
+  String signUR(int max_fragment_length) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int status() {
+    return wownero.UnsignedTransaction_status(unsignedTransactionPtr);
+  }
+  
+  @override
+  int txCount() {
+    return wownero.UnsignedTransaction_txCount(unsignedTransactionPtr);
+  }
+  
+  
+}
+
+class WowneroWallet implements Wallet2Wallet {
+  WowneroWallet(this.walletPtr);
+
+  final wownero.wallet walletPtr;
+  
+  @override
+  void addSubaddress({required int accountIndex, String label = ""}) {
+    wownero.Wallet_addSubaddress(walletPtr, accountIndex: accountIndex, label: label);
+  }
+  
+  @override
+  void addSubaddressAccount({String label = ""}) {
+    wownero.Wallet_addSubaddressAccount(walletPtr, label: label);
+  }
+  
+  @override
+  String address({int accountIndex = 0, int addressIndex = 0}) {
+    return wownero.Wallet_address(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex);
+  }
+  
+  @override
+  Wallet2AddressBook addressBook() {
+    return WowneroAddressBook(wownero.Wallet_addressBook(walletPtr));
+  }
+  
+  @override
+  bool addressValid(String address, int networkType) {
+    return wownero.Wallet_addressValid(address, networkType);
+  }
+  
+  @override
+  int amountFromDouble(double amount) {
+    return wownero.Wallet_amountFromDouble(amount);
+  }
+  
+  @override
+  int amountFromString(String amount) {
+    return wownero.Wallet_amountFromString(amount);
+  }
+  
+  @override
+  int approximateBlockChainHeight() {
+    return wownero.Wallet_approximateBlockChainHeight(walletPtr);
+  }
+  
+  @override
+  int autoRefreshInterval() {
+    return wownero.Wallet_autoRefreshInterval(walletPtr);
+  }
+  
+  @override
+  int balance({required int accountIndex}) {
+    return wownero.Wallet_balance(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  int blockChainHeight() {
+    return wownero.Wallet_blockChainHeight(walletPtr);
+  }
+  
+  @override
+  Wallet2Coins coins() {
+    return WowneroCoins(wownero.Wallet_coins(walletPtr));
+  }
+  
+  @override
+  int coldKeyImageSync({required int spent, required int unspent}) {
+    return wownero.Wallet_coldKeyImageSync(walletPtr, spent: spent, unspent: unspent);
+  }
+  
+  @override
+  bool connectToDaemon() {
+    return wownero.Wallet_connectToDaemon(walletPtr);
+  }
+  
+  @override
+  int connected() {
+    return wownero.Wallet_connected(walletPtr);
+  }
+  
+  @override
+  String createPolyseed({String language = "English"}) {
+    return wownero.Wallet_createPolyseed(language: language);
+  }
+  
+  @override
+  Wallet2PendingTransaction createTransaction({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 []}) {
+    final transaction = wownero.Wallet_createTransaction(walletPtr, dst_addr: dst_addr, payment_id: payment_id, amount: amount, mixin_count: mixin_count, pendingTransactionPriority: pendingTransactionPriority, subaddr_account: subaddr_account, preferredInputs: preferredInputs);
+    return WowneroPendingTransaction(transaction);
+  }
+  
+  @override
+  Wallet2PendingTransaction createTransactionMultDest({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 []}) {
+    final transaction = wownero.Wallet_createTransactionMultDest(walletPtr, dstAddr: dstAddr, paymentId: paymentId, isSweepAll: isSweepAll, amounts: amounts, mixinCount: mixinCount, pendingTransactionPriority: pendingTransactionPriority, subaddr_account: subaddr_account, preferredInputs: preferredInputs);
+    return WowneroPendingTransaction(transaction);
+  }
+  
+  @override
+  bool createWatchOnly({required String path, required String password, required String language}) {
+    return wownero.Wallet_createWatchOnly(walletPtr, path: path, password: password, language: language);
+  }
+  
+  @override
+  int daemonBlockChainHeight() {
+    return wownero.Wallet_daemonBlockChainHeight(walletPtr);
+  }
+  
+  @override
+  int defaultMixin() {
+    return wownero.Wallet_defaultMixin(walletPtr);
+  }
+  
+  @override
+  String deviceShowAddress({required int accountIndex, required int addressIndex}) {
+    return wownero.Wallet_deviceShowAddress(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex);
+  }
+  
+  @override
+  String displayAmount(int amount) {
+    return wownero.Wallet_displayAmount(amount);
+  }
+  
+  @override
+  String errorString() {
+    return wownero.Wallet_errorString(walletPtr);
+  }
+  
+  @override
+  int estimateBlockChainHeight() {
+    return wownero.Wallet_estimateBlockChainHeight(walletPtr);
+  }
+  
+  @override
+  String exchangeMultisigKeys({required List<String> info, required bool force_update_use_with_caution}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool exportKeyImages(String filename, {required bool all}) {
+    return wownero.Wallet_exportKeyImages(walletPtr, filename, all: all);
+  }
+  
+  @override
+  String exportKeyImagesUR({int max_fragment_length = 130, bool all = false}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  List<String> exportMultisigImages({required List<String> info}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool exportOutputs(String filename, {required bool all}) {
+    return wownero.Wallet_exportOutputs(walletPtr, filename, all: all);
+  }
+  
+  @override
+  String exportOutputsUR({int max_fragment_length = 130, bool all = false}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  String filename() {
+    return wownero.Wallet_filename(walletPtr);
+  }
+  
+  @override
+  String genPaymentId() {
+    return wownero.Wallet_genPaymentId();
+  }
+  
+  @override
+  int getBackgroundSyncType() {
+    return wownero.Wallet_getBackgroundSyncType(walletPtr);
+  }
+  
+  @override
+  int getBytesReceived() {
+    return wownero.Wallet_getBytesReceived(walletPtr);
+  }
+  
+  @override
+  int getBytesSent() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  String getCacheAttribute({required String key}) {
+    return wownero.Wallet_getCacheAttribute(walletPtr, key: key);
+  }
+  
+  @override
+  int getDeviceType() {
+    return wownero.Wallet_getDeviceType(walletPtr);
+  }
+  
+  @override
+  String getMultisigInfo() {
+    return wownero.Wallet_getMultisigInfo(walletPtr);
+  }
+  
+  @override
+  String getPassword() {
+    return wownero.Wallet_getPassword(walletPtr);
+  }
+  
+  @override
+  String getPolyseed({required String passphrase}) {
+    return wownero.Wallet_getPolyseed(walletPtr, passphrase: passphrase);
+  }
+  
+  @override
+  Pointer<UnsignedChar> getReceivedFromDevice() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int getReceivedFromDeviceLength() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int getRefreshFromBlockHeight() {
+    return wownero.Wallet_getRefreshFromBlockHeight(walletPtr);
+  }
+  
+  @override
+  String getSeedLanguage() {
+    return wownero.Wallet_getSeedLanguage(walletPtr);
+  }
+  
+  @override
+  Pointer<UnsignedChar> getSendToDevice() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int getSendToDeviceLength() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool getStateIsConnected() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  String getSubaddressLabel({required int accountIndex, required int addressIndex}) {
+    return wownero.Wallet_getSubaddressLabel(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex);
+  }
+  
+  @override
+  String getTxKey({required String txid}) {
+    return wownero.Wallet_getTxKey(walletPtr, txid: txid);
+  }
+  
+  @override
+  String getUserNote({required String txid}) {
+    return wownero.Wallet_getUserNote(walletPtr, txid: txid);
+  }
+  
+  @override
+  bool getWaitsForDeviceReceive() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool getWaitsForDeviceSend() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  Wallet2WalletListener getWalletListener() {
+    final listener = wownero.WOWNERO_cw_getWalletListener(walletPtr);
+    return WowneroWalletListener(listener);
+  }
+  
+  @override
+  int hasMultisigPartialKeyImages() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool hasUnknownKeyImages() {
+    return wownero.Wallet_hasUnknownKeyImages(walletPtr);
+  }
+  
+  @override
+  Wallet2TransactionHistory history() {
+    return WowneroTransactionHistory(wownero.Wallet_history(walletPtr));
+  }
+  
+  @override
+  bool importKeyImages(String filename) {
+    return wownero.Wallet_importKeyImages(walletPtr, filename);
+  }
+  
+  @override
+  bool importKeyImagesUR(String input) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int importMultisigImages({required List<String> info}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool importOutputs(String filename) {
+    return wownero.Wallet_importOutputs(walletPtr, filename);
+  }
+  
+  @override
+  bool importOutputsUR(String input) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool init({required String daemonAddress, int upperTransacationSizeLimit = 0, String daemonUsername = "", String daemonPassword = "", bool useSsl = false, bool lightWallet = false, String proxyAddress = ""}) {
+    return wownero.Wallet_init(walletPtr, daemonAddress: daemonAddress, upperTransacationSizeLimit: upperTransacationSizeLimit, daemonUsername: daemonUsername, daemonPassword: daemonPassword, useSsl: useSsl, lightWallet: lightWallet, proxyAddress: proxyAddress);
+  }
+  
+  @override
+  void init3({required String argv0, required String defaultLogBaseName, required String logPath, required bool console}) {
+    return wownero.Wallet_init3(walletPtr, argv0: argv0, defaultLogBaseName: defaultLogBaseName, logPath: logPath, console: console);
+  }
+  
+  @override
+  String integratedAddress({required String paymentId}) {
+    return wownero.Wallet_integratedAddress(walletPtr, paymentId: paymentId);
+  }
+  
+  @override
+  bool isBackgroundSyncing() {
+    return wownero.Wallet_isBackgroundSyncing(walletPtr);
+  }
+  
+  @override
+  bool isBackgroundWallet() {
+    return wownero.Wallet_isBackgroundWallet(walletPtr);
+  }
+  
+  @override
+  bool isKeysFileLocked() {
+    return wownero.Wallet_isKeysFileLocked(walletPtr);
+  }
+  
+  @override
+  bool isOffline() {
+    return wownero.Wallet_isOffline(walletPtr);
+  }
+  
+  @override
+  void keyReuseMitigation2({required bool mitigation}) {
+    wownero.Wallet_keyReuseMitigation2(walletPtr, mitigation: mitigation);
+  }
+  
+  @override
+  bool keyValid({required String secret_key_string, required String address_string, required bool isViewKey, required int nettype}) {
+    return wownero.Wallet_keyValid(secret_key_string: secret_key_string, address_string: address_string, isViewKey: isViewKey, nettype: nettype);
+  }
+  
+  @override
+  String keyValid_error({required String secret_key_string, required String address_string, required bool isViewKey, required int nettype}) {
+    return wownero.Wallet_keyValid_error(secret_key_string: secret_key_string, address_string: address_string, isViewKey: isViewKey, nettype: nettype);
+  }
+  
+  @override
+  String keysFilename() {
+    return wownero.Wallet_keysFilename(walletPtr);
+  }
+  
+  @override
+  Wallet2UnsignedTransaction loadUnsignedTx({required String unsigned_filename}) {
+    final tx = wownero.Wallet_loadUnsignedTx(walletPtr, unsigned_filename: unsigned_filename);
+    return WowneroUnsignedTransaction(tx);
+  }
+  
+  @override
+  Wallet2UnsignedTransaction loadUnsignedTxUR({required String input}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool lockKeysFile() {
+    return wownero.Wallet_lockKeysFile(walletPtr);
+  }
+  
+  @override
+  String makeMultisig({required List<String> info, required int threshold}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int maximumAllowedAmount() {
+    return wownero.Wallet_maximumAllowedAmount();
+  }
+  
+  @override
+  Wallet2MultisigState multisig() {
+    throw UnimplementedError();
+  }
+  
+  @override
+  int nettype() {
+    return wownero.Wallet_nettype(walletPtr);
+  }
+  
+  @override
+  int numSubaddressAccounts() {
+    return wownero.Wallet_numSubaddressAccounts(walletPtr);
+  }
+  
+  @override
+  int numSubaddresses({required int accountIndex}) {
+    return wownero.Wallet_numSubaddresses(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  String path() {
+    return wownero.Wallet_path(walletPtr);
+  }
+  
+  @override
+  void pauseRefresh() {
+    wownero.Wallet_pauseRefresh(walletPtr);
+  }
+  
+  @override
+  String paymentIdFromAddress({required String strarg, required int nettype}) {
+    return wownero.Wallet_paymentIdFromAddress(nettype: nettype, strarg: strarg);
+  }
+  
+  @override
+  bool paymentIdValid(String paymentId) {
+    return wownero.Wallet_paymentIdValid(paymentId);
+  }
+  
+  @override
+  String publicMultisigSignerKey() {
+    return wownero.Wallet_publicMultisigSignerKey(walletPtr);
+  }
+  
+  @override
+  String publicSpendKey() {
+    return wownero.Wallet_publicSpendKey(walletPtr);
+  }
+  
+  @override
+  String publicViewKey() {
+    return wownero.Wallet_publicViewKey(walletPtr);
+  }
+  
+  @override
+  bool reconnectDevice() {
+    return wownero.Wallet_reconnectDevice(walletPtr);
+  }
+  
+  @override
+  bool refresh() {
+    return wownero.Wallet_refresh(walletPtr);
+  }
+  
+  @override
+  void refreshAsync() {
+    wownero.Wallet_refreshAsync(walletPtr);
+  }
+  
+  @override
+  bool rescanBlockchain() {
+    return wownero.Wallet_rescanBlockchain(walletPtr);
+  }
+  
+  @override
+  void rescanBlockchainAsync() {
+    wownero.Wallet_rescanBlockchainAsync(walletPtr);
+  }
+  
+  @override
+  bool rescanSpent() {
+    return wownero.Wallet_rescanSpent(walletPtr);
+  }
+  
+  @override
+  Wallet2PendingTransaction restoreMultisigTransaction({required String signData}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  String secretSpendKey() {
+    return wownero.Wallet_secretSpendKey(walletPtr);
+  }
+  
+  @override
+  String secretViewKey() {
+    return wownero.Wallet_secretViewKey(walletPtr);
+  }
+  
+  @override
+  String seed({required String seedOffset}) {
+    return wownero.Wallet_seed(walletPtr, seedOffset: seedOffset);
+  }
+  
+  @override
+  void segregatePreForkOutputs({required bool segregate}) {
+    wownero.Wallet_segregatePreForkOutputs(walletPtr, segregate: segregate);
+  }
+  
+  @override
+  void segregationHeight({required int height}) {
+    wownero.Wallet_segregationHeight(walletPtr, height: height);
+  }
+  
+  @override
+  void setAutoRefreshInterval({required int millis}) {
+    wownero.Wallet_setAutoRefreshInterval(walletPtr, millis: millis);
+  }
+  
+  @override
+  bool setCacheAttribute({required String key, required String value}) {
+    return wownero.Wallet_setCacheAttribute(walletPtr, key: key, value: value);
+  }
+  
+  @override
+  void setDefaultMixin(int arg) {
+    wownero.Wallet_setDefaultMixin(walletPtr, arg);
+  }
+  
+  @override
+  bool setDevicePin({required String passphrase}) {
+    return wownero.Wallet_setDevicePin(walletPtr, passphrase: passphrase);
+  }
+  
+  @override
+  void setDeviceReceivedData(Pointer<UnsignedChar> data, int len) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  void setDeviceSendData(Pointer<UnsignedChar> data, int len) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  void setOffline({required bool offline}) {
+    wownero.Wallet_setOffline(walletPtr, offline: offline);
+  }
+  
+  @override
+  bool setPassword({required String password}) {
+    return wownero.Wallet_setPassword(walletPtr, password: password);
+  }
+  
+  @override
+  void setProxy({required String address}) {
+    wownero.Wallet_setProxy(walletPtr, address: address);
+  }
+  
+  @override
+  void setRecoveringFromDevice({required bool recoveringFromDevice}) {
+    wownero.Wallet_setRecoveringFromDevice(walletPtr, recoveringFromDevice: recoveringFromDevice);
+  }
+  
+  @override
+  void setRecoveringFromSeed({required bool recoveringFromSeed}) {
+    wownero.Wallet_setRecoveringFromSeed(walletPtr, recoveringFromSeed: recoveringFromSeed);
+  }
+  
+  @override
+  void setRefreshFromBlockHeight({required int refresh_from_block_height}) {
+    wownero.Wallet_setRefreshFromBlockHeight(walletPtr, refresh_from_block_height: refresh_from_block_height);
+  }
+  
+  @override
+  void setSeedLanguage({required String language}) {
+    wownero.Wallet_setSeedLanguage(walletPtr, language: language);
+  }
+  
+  @override
+  void setSubaddressLabel({required int accountIndex, required int addressIndex, required String label}) {
+    wownero.Wallet_setSubaddressLabel(walletPtr, accountIndex: accountIndex, addressIndex: addressIndex, label: label);
+  }
+  
+  @override
+  void setSubaddressLookahead({required int major, required int minor}) {
+    wownero.Wallet_setSubaddressLookahead(walletPtr, major: major, minor: minor);
+  }
+  
+  @override
+  void setTrustedDaemon({required bool arg}) {
+    wownero.Wallet_setTrustedDaemon(walletPtr, arg: arg);
+  }
+  
+  @override
+  bool setUserNote({required String txid, required String note}) {
+    return wownero.Wallet_setUserNote(walletPtr, txid: txid, note: note);
+  }
+  
+  @override
+  bool setupBackgroundSync({required int backgroundSyncType, required String walletPassword, required String backgroundCachePassword}) {
+    return wownero.Wallet_setupBackgroundSync(walletPtr, backgroundSyncType: backgroundSyncType, walletPassword: walletPassword, backgroundCachePassword: backgroundCachePassword);
+  }
+  
+  @override
+  String signMessage({required String message, required String address}) {
+    return wownero.Wallet_signMessage(walletPtr, message: message, address: address);
+  }
+  
+  @override
+  bool startBackgroundSync() {
+    return wownero.Wallet_startBackgroundSync(walletPtr);
+  }
+  
+  @override
+  void startRefresh() {
+    wownero.Wallet_startRefresh(walletPtr);
+  }
+  
+  @override
+  int status() {
+    return wownero.Wallet_status(walletPtr);
+  }
+  
+  @override
+  void stop() {
+    wownero.Wallet_stop(walletPtr);
+  }
+  
+  @override
+  bool stopBackgroundSync(String walletPassword) {
+    return wownero.Wallet_stopBackgroundSync(walletPtr, walletPassword);
+  }
+  
+  @override
+  bool store({String path = ""}) {
+    return wownero.Wallet_store(walletPtr, path: path);
+  }
+  
+  @override
+  Wallet2Subaddress subaddress() {
+    return WowneroSubaddress(wownero.Wallet_subaddress(walletPtr));
+  }
+  
+  @override
+  Wallet2SubaddressAccount subaddressAccount() {
+    return WowneroSubaddressAccount(wownero.Wallet_subaddressAccount(walletPtr));
+  }
+  
+  @override
+  bool submitTransaction(String filename) {
+    return wownero.Wallet_submitTransaction(walletPtr, filename);
+  }
+  
+  @override
+  bool submitTransactionUR(String input) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  bool synchronized() {
+    return wownero.Wallet_synchronized(walletPtr);
+  }
+  
+  @override
+  bool trustedDaemon() {
+    return wownero.Wallet_trustedDaemon(walletPtr);
+  }
+  
+  @override
+  bool unlockKeysFile() {
+    return wownero.Wallet_unlockKeysFile(walletPtr);
+  }
+  
+  @override
+  int unlockedBalance({required int accountIndex}) {
+    return wownero.Wallet_unlockedBalance(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  int useForkRules({required int version, required int earlyBlocks}) {
+    return wownero.Wallet_useForkRules(walletPtr, version: version, earlyBlocks: earlyBlocks);
+  }
+  
+  @override
+  bool verifySignedMessage({required String message, required String address, required String signature}) {
+    return wownero.Wallet_verifySignedMessage(walletPtr, message: message, address: address, signature: signature);
+  }
+  
+  @override
+  int viewOnlyBalance({required int accountIndex}) {
+    return wownero.Wallet_viewOnlyBalance(walletPtr, accountIndex: accountIndex);
+  }
+  
+  @override
+  bool watchOnly() {
+    return wownero.Wallet_watchOnly(walletPtr);
+  }
+}
+
+class WowneroWalletManager implements Wallet2WalletManager {
+  WowneroWalletManager(this.wmPtr);
+
+  final wownero.WalletManager wmPtr;
+  
+  @override
+  Future<int> blockTarget() async {
+    return wownero.WalletManager_blockTarget(wmPtr);
+  }
+  
+  @override
+  Future<int> blockchainHeight() async {
+    return wownero.WalletManager_blockchainHeight(wmPtr);
+  }
+  
+  @override
+  Future<int> blockchainTargetHeight() async {
+    return wownero.WalletManager_blockchainTargetHeight(wmPtr);
+  }
+  
+  @override
+  Wallet2Wallet createDeterministicWalletFromSpendKey({required String path, required String password, String language = "English", int networkType = 0, required String spendKeyString, required bool newWallet, required int restoreHeight, int kdfRounds = 1}) {
+    final wallet = wownero.WalletManager_createDeterministicWalletFromSpendKey(wmPtr, path: path, password: password, language: language, networkType: networkType, spendKeyString: spendKeyString, newWallet: newWallet, restoreHeight: restoreHeight, kdfRounds: kdfRounds);
+    return WowneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWallet({required String path, required String password, String language = "English", int networkType = 0}) {
+    final wallet = wownero.WalletManager_createWallet(wmPtr, path: path, password: password, language: language, networkType: networkType);
+    return WowneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWalletFromDevice({required String path, required String password, int networkType = 0, required String deviceName, int restoreHeight = 0, String subaddressLookahead = "", int kdfRounds = 1}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  Wallet2Wallet createWalletFromKeys({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}) {
+    final wallet = wownero.WalletManager_createWalletFromKeys(wmPtr, path: path, password: password, language: language, nettype: nettype, restoreHeight: restoreHeight, addressString: addressString, viewKeyString: viewKeyString, spendKeyString: spendKeyString);
+    return WowneroWallet(wallet);
+  }
+  
+  @override
+  Wallet2Wallet createWalletFromPolyseed({required String path, required String password, int networkType = 0, required String mnemonic, required String seedOffset, required bool newWallet, required int restoreHeight, required int kdfRounds}) {
+    final wallet = wownero.WalletManager_createWalletFromPolyseed(wmPtr, path: path, password: password, networkType: networkType, mnemonic: mnemonic, seedOffset: seedOffset, newWallet: newWallet, restoreHeight: restoreHeight, kdfRounds: kdfRounds);
+    return WowneroWallet(wallet);
+  }
+  
+  @override
+  String errorString() {
+    return wownero.WalletManager_errorString(wmPtr);
+  }
+  
+  @override
+  List<String> findWallets({required String path}) {
+    return wownero.WalletManager_findWallets(wmPtr, path: path);
+  }
+  
+  @override
+  bool isMining() {
+    return wownero.WalletManager_isMining(wmPtr);
+  }
+  
+  @override
+  double miningHashRate() {
+    return wownero.WalletManager_miningHashRate(wmPtr);
+  }
+  
+  @override
+  int networkDifficulty() {
+    return wownero.WalletManager_networkDifficulty(wmPtr);
+  }
+  
+  @override
+  Wallet2Wallet openWallet({required String path, required String password, int networkType = 0}) {
+    final wallet = wownero.WalletManager_openWallet(wmPtr, path: path, password: password, networkType: networkType);
+    return WowneroWallet(wallet);
+  }
+  
+  @override
+  int queryWalletDevice({required String keysFileName, required String password, required int kdfRounds}) {
+    throw UnimplementedError();
+  }
+  
+  @override
+  Wallet2Wallet recoveryWallet({required String path, required String password, required String mnemonic, int networkType = 0, required int restoreHeight, int kdfRounds = 0, required String seedOffset}) {
+    final wallet = wownero.WalletManager_recoveryWallet(wmPtr, path: path, password: password, mnemonic: mnemonic, networkType: networkType, restoreHeight: restoreHeight, kdfRounds: kdfRounds, seedOffset: seedOffset);
+    return WowneroWallet(wallet);
+  }
+  
+  @override
+  String resolveOpenAlias({required String address, required bool dnssecValid}) {
+    return wownero.WalletManager_resolveOpenAlias(wmPtr, address: address, dnssecValid: dnssecValid);
+  }
+  
+  @override
+  void setDaemonAddress(String address) {
+    wownero.WalletManager_setDaemonAddress(wmPtr, address);
+  }
+  
+  @override
+  bool setProxy(String address) {
+    return wownero.WalletManager_setProxy(wmPtr, address);
+  }
+  
+  @override
+  bool startMining({required String address, required int threads, required bool backgroundMining, required bool ignoreBattery}) {
+    return wownero.WalletManager_startMining(wmPtr, address: address, threads: threads, backgroundMining: backgroundMining, ignoreBattery: ignoreBattery);
+  }
+  
+  @override
+  bool stopMining(String address) {
+    return wownero.WalletManager_stopMining(wmPtr, address);
+  }
+  
+  @override
+  bool verifyWalletPassword({required String keysFileName, required String password, required bool noSpendKey, required int kdfRounds}) {
+    return wownero.WalletManager_verifyWalletPassword(wmPtr, keysFileName: keysFileName, password: password, noSpendKey: noSpendKey, kdfRounds: kdfRounds);
+  }
+  
+  @override
+  bool walletExists(String path) {
+    return wownero.WalletManager_walletExists(wmPtr, path);
+  }
+}
+
+class WowneroWalletManagerFactory implements Wallet2WalletManagerFactory {
+  @override
+  Wallet2WalletManager getWalletManager() {
+    return WowneroWalletManager(wownero.WalletManagerFactory_getWalletManager());
+  }
+
+  @override
+  void setLogCategories(String categories) {
+    wownero.WalletManagerFactory_setLogCategories(categories);
+  }
+
+  @override
+  void setLogLevel(int level) {
+    wownero.WalletManagerFactory_setLogLevel(level);
+  }
+}