Embed monero.dart into monero_c (#16)

18 files changed, 18827 insertions, 16 deletions

diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index a544af0..ad064db 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -1,24 +1,16 @@
-FROM debian:bookworm
+FROM ghcr.io/cirruslabs/flutter:3.22.2
+# FROM debian:bookworm
 
 # Install dependencies
 
 RUN apt update \
     && apt install -y wget build-essential pkg-config autoconf libtool ccache make cmake gcc g++ git curl lbzip2 libtinfo5 gperf gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64 gcc-mingw-w64-i686 g++-mingw-w64-i686 build-essential pkg-config autoconf libtool ccache make cmake gcc g++ git curl lbzip2 libtinfo5 gperf unzip python-is-python3 build-essential pkg-config autoconf libtool ccache make cmake gcc g++ git curl lbzip2 libtinfo5 gperf gcc-aarch64-linux-gnu g++-aarch64-linux-gnu gcc-i686-linux-gnu g++-i686-linux-gnu pkg-config autoconf libtool ccache make cmake gcc g++ git curl lbzip2 libtinfo5 gperf python-is-python3 zsh
 
-# Install zsh and configure it
-
-ARG USERNAME=user
-ARG USER_UID=1000
-ARG USER_GID=$USER_UID
+RUN bash -c 'if [[ "$(uname -m)" == "aarch64" || "$(uname -m)" == "arm64" ]] then sudo rm -rf /opt/android-sdk-linux/platform-tools; fi'
 
-RUN groupadd --gid $USER_GID $USERNAME \
-    && useradd --uid $USER_UID --gid $USER_GID -m $USERNAME \
-    && apt-get update \
-    && apt-get install -y sudo \
-    && echo $USERNAME ALL=\(root\) NOPASSWD:ALL > /etc/sudoers.d/$USERNAME \
-    && chmod 0440 /etc/sudoers.d/$USERNAME
+# Install zsh and configure it
 
-USER $USERNAME
+USER ubuntu
 
 RUN sh -c "$(wget -O- https://github.com/deluan/zsh-in-docker/releases/download/v1.2.0/zsh-in-docker.sh)" \
     -t robbyrussell 
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 90a29f4..f6edac1 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -16,8 +16,10 @@
                 "terminal.integrated.profiles.linux": { "zsh": { "path": "/bin/zsh" } }
             },
 			"extensions": [
+                "dart-code.flutter",
+                "dart-code.dart-code"
 			]
 		}
 	},
-	"remoteUser": "user"
+	"remoteUser": "ubuntu"
 }
diff --git a/.github/workflows/dart_bindings.yaml b/.github/workflows/dart_bindings.yaml
new file mode 100644
index 0000000..a1e7984
--- /dev/null
+++ b/.github/workflows/dart_bindings.yaml
@@ -0,0 +1,39 @@
+name: Check if dart bindings are in sync
+on:
+  pull_request:
+    types: [opened, reopened, synchronize]
+permissions:
+  issues: write
+  pull-requests: write
+jobs:
+  android:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          submodules: recursive
+      - uses: 8BitJonny/gh-get-current-pr@3.0.0
+        id: PR
+      - uses: subosito/flutter-action@v2
+        with:
+          channel: stable
+      - name: generate bindings
+        run: |
+          cd impls/monero.dart
+          ./update_bindings.sh
+      - name: check if git tree is clean
+        run: |
+          if [ -z "$(git status --porcelain)" ]; then 
+            exit 0
+          else 
+            exit 1
+          fi
+      - name: Create or update comment
+        if: failure()
+        uses: peter-evans/create-or-update-comment@v4
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          body: |
+            Invalid bindings found in monero.dart, make sure to run `./impls/monero.dart/update_bindings.sh`
+            
\ No newline at end of file
diff --git a/.github/workflows/xmruw.yaml b/.github/workflows/xmruw.yaml
index 4366f7a..95f42ea 100644
--- a/.github/workflows/xmruw.yaml
+++ b/.github/workflows/xmruw.yaml
@@ -1,11 +1,15 @@
-name: Build xmruw
-run-name: Building xmruw for supported targets
+name: Build 
+
+
+
+
 on:
   pull_request:
     types: [opened, reopened, synchronize]
 permissions:
   issues: write
   pull-requests: write
+
 jobs:
   android:
     strategy:
diff --git a/impls/monero.dart/.gitignore b/impls/monero.dart/.gitignore
new file mode 100644
index 0000000..0b34a7d
--- /dev/null
+++ b/impls/monero.dart/.gitignore
@@ -0,0 +1,12 @@
+# https://dart.dev/guides/libraries/private-files
+# Created by `dart pub`
+.dart_tool/
+
+# Avoid committing pubspec.lock for library packages; see
+# https://dart.dev/guides/libraries/private-files#pubspeclock.
+pubspec.lock
+
+wallet2_api_c.h
+
+# FVM Version Cache
+.fvm/
\ No newline at end of file
diff --git a/impls/monero.dart/LICENSE b/impls/monero.dart/LICENSE
new file mode 100644
index 0000000..f288702
--- /dev/null
+++ b/impls/monero.dart/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.
diff --git a/impls/monero.dart/README.md b/impls/monero.dart/README.md
new file mode 100644
index 0000000..72504e7
--- /dev/null
+++ b/impls/monero.dart/README.md
@@ -0,0 +1,74 @@
+# monero.dart
+
+## Usage
+
+```
+monero:
+  git:
+    url: https://github.com/mrcyjanek/monero_c
+    ref: master
+    path: impls/monero.dart
+```
+
+```dart
+import 'package: monero/monero.dart' as monero;
+
+void main() {
+    final wm = monero.WalletManagerFactory_getWalletManager();
+    final w = monero.WalletManager_openWallet({...});
+    print(monero.Wallet_balance(w));
+}
+```
+
+If you need more advanced usage, to for example use the code in an isolate, some workarounding is required **NOTE: from now on you manage your own memory partialy**.
+
+Simplest example is this:
+
+```dart
+final addr = w.address; 
+final height = await Isolate.run(() async {
+    return monero.lib.MONERO_Wallet_daemonBlockChainHeight(Pointer.fromAddress(addr));
+});
+```
+
+It gets even funnier when sending a transaction
+
+```dart
+final ptrAddr = xmrwPtr!.address;
+final dstAddrPtr = txData.recipients!.first.address.toNativeUtf8().address;
+final paymentAddrPtr = ''.toNativeUtf8().address;
+final preferredInputsPtr = ''.toNativeUtf8().address;
+final separatorPtr = ''.toNativeUtf8().address;
+final amount = txData.recipients!.first.amount.raw.toInt();
+final txPtrAddr = await Isolate.run(
+    () {
+        monero.lib ??= MoneroC(DynamicLibrary.open(monero.libPath));
+        final txPtr = monero.lib!.MONERO_Wallet_createTransaction(
+            Pointer.fromAddress(ptrAddr), 
+            Pointer.fromAddress(dstAddrPtr).cast(), 
+            Pointer.fromAddress(paymentAddrPtr).cast(), 
+            amount, 0, 0, 0, 
+            Pointer.fromAddress(preferredInputsPtr).cast(), 
+            Pointer.fromAddress(separatorPtr).cast(),
+        );
+        // Nothing hits better than managing memory in GC language :)
+        return txPtr.address;
+    },
+    debugName: 'MONERO_Wallet_createTransaction',
+);
+
+final txPtr = Pointer.fromAddress(txPtrAddr).cast<Void>();
+calloc.free(Pointer.fromAddress(dstAddrPtr));
+calloc.free(Pointer.fromAddress(paymentAddrPtr));
+calloc.free(Pointer.fromAddress(preferredInputsPtr));
+calloc.free(Pointer.fromAddress(separatorPtr));
+```
+
+Async api will be made as a part of the generator update, too much effort under current design.
+
+## Building
+
+```bash
+$ bash update_bindings.sh
+$ # you are done, this is a library, what more did you expect?
+```
\ No newline at end of file
diff --git a/impls/monero.dart/analysis_options.yaml b/impls/monero.dart/analysis_options.yaml
new file mode 100644
index 0000000..dee8927
--- /dev/null
+++ b/impls/monero.dart/analysis_options.yaml
@@ -0,0 +1,30 @@
+# This file configures the static analysis results for your project (errors,
+# warnings, and lints).
+#
+# This enables the 'recommended' set of lints from `package:lints`.
+# This set helps identify many issues that may lead to problems when running
+# or consuming Dart code, and enforces writing Dart using a single, idiomatic
+# style and format.
+#
+# If you want a smaller set of lints you can change this to specify
+# 'package:lints/core.yaml'. These are just the most critical lints
+# (the recommended set includes the core lints).
+# The core lints are also what is used by pub.dev for scoring packages.
+
+include: package:lints/recommended.yaml
+
+# Uncomment the following section to specify additional rules.
+
+# linter:
+#   rules:
+#     - camel_case_types
+
+# analyzer:
+#   exclude:
+#     - path/to/excluded/files/**
+
+# For more information about the core and recommended set of lints, see
+# https://dart.dev/go/core-lints
+
+# For additional information about configuring this file, see
+# https://dart.dev/guides/language/analysis-options
diff --git a/impls/monero.dart/ffigen_monero.yaml b/impls/monero.dart/ffigen_monero.yaml
new file mode 100644
index 0000000..3732939
--- /dev/null
+++ b/impls/monero.dart/ffigen_monero.yaml
@@ -0,0 +1,11 @@
+name: MoneroC
+description: monero_c bindings
+output: 'lib/src/generated_bindings_monero.g.dart'
+headers:
+  entry-points:
+    - 'monero_wallet2_api_c.h'
+
+exclude-all-by-default: true
+functions:
+  include:
+    - "MONERO_.+"
\ No newline at end of file
diff --git a/impls/monero.dart/ffigen_wownero.yaml b/impls/monero.dart/ffigen_wownero.yaml
new file mode 100644
index 0000000..e057fa1
--- /dev/null
+++ b/impls/monero.dart/ffigen_wownero.yaml
@@ -0,0 +1,11 @@
+name: WowneroC
+description: monero_c wownero bindings
+output: 'lib/src/generated_bindings_wownero.g.dart'
+headers:
+  entry-points:
+    - 'wownero_wallet2_api_c.h'
+
+exclude-all-by-default: true
+functions:
+  include:
+    - "WOWNERO_.+"
\ No newline at end of file
diff --git a/impls/monero.dart/lib/monero.dart b/impls/monero.dart/lib/monero.dart
new file mode 100644
index 0000000..818caf7
--- /dev/null
+++ b/impls/monero.dart/lib/monero.dart
@@ -0,0 +1,3926 @@
+library;
+
+// Are we memory safe?
+// There is a simple way to check that:
+// 1) Rewrite everything in rust
+// Or, assuming we are sane
+// 1) grep -E 'toNative|^String ' lib/monero.dart | grep -v '^//' | grep -v '^String libPath = ' | wc -l
+//    This will print number of all things that produce pointers
+// 2) grep .free lib/monero.dart | grep -v '^//' | wc -l
+//    This will print number of all free calls, these numbers should match
+
+// Wrapper around generated_bindings.g.dart - to provide easy access to the
+// underlying functions, feel free to not use it at all.
+
+//  _____________ PendingTransaction is just a typedef for Pointer<Void> (which is void* on C side)
+// /                   _____________ Wallet class, we didn't specify the MONERO prefix because we import the monero.dart code with monero prefix
+// |                  /       _____________ createTransaction function, from the upstream in the class Wallet
+// |                  |      /
+// PendingTransaction Wallet_createTransaction(wallet ptr, <------------- wallet is a typedef for Pointer<Void>
+//     {required String dst_addr,--------------------------------\ All of the parameters that are used in this function
+//     required String payment_id,                  _____________/ String - will get casted into const char*
+//     required int amount,                        /
+//     required int mixin_count,                  /                int - goes as it is
+//     required int pendingTransactionPriority,  /
+//     required int subaddr_account,            /
+//     List<String> preferredInputs = const []}) {                 List<String> - gets joined and passed as 2 separate parameters to be split in the C side____
+//   debugStart?.call('MONERO_Wallet_createTransaction'); <------------- debugStart functions just marks the function as currently being executed, used        |
+//   lib ??= MoneroC(DynamicLibrary.open(libPath));                    \_for performance debugging                                                             |
+//   \_____________ Load the library in case it is not loaded                                                                                                  |
+//   final dst_addr_ = dst_addr.toNativeUtf8().cast<Char>(); -----------------| Cast the strings into Chars so it can be used as a parameter in a function     |
+//   final payment_id_ = payment_id.toNativeUtf8().cast<Char>(); -------------| generated via ffigen                                                           |
+//   final preferredInputs_ = preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast<Char>(); <---------------------------------------------------------/
+//   final s = lib!.WOWNERO_Wallet_createTransaction(-------------|
+//     ptr,                                                       |
+//     dst_addr_,                                                 |
+//     payment_id_,                                               |
+//     amount,                                                    |
+//     mixin_count,                                               | Call the native function using generated code
+//     pendingTransactionPriority,                                |
+//     subaddr_account,                                           |
+//     preferredInputs_,                                          |
+//     defaultSeparator,                                          |
+//   );___________________________________________________________/
+//   calloc.free(dst_addr_);---------------| Free the memory once we don't need it
+//   calloc.free(payment_id_);-------------|
+//   debugEnd?.call('MONERO_Wallet_createTransaction'); <------------- Mark the function as executed
+//   return s; <------------- return the value
+// }
+//
+// Extra case is happening when we have a function call that returns const char* as we have to be memory safe
+// String PendingTransaction_txid(PendingTransaction ptr, String separator) {
+//   debugStart?.call('MONERO_PendingTransaction_txid');
+//   lib ??= MoneroC(DynamicLibrary.open(libPath));
+//   final separator_ = separator.toNativeUtf8().cast<Char>();
+//   final txid = lib!.MONERO_PendingTransaction_txid(ptr, separator_);
+//   calloc.free(separator_);
+//   debugEnd?.call('MONERO_PendingTransaction_txid');
+//   try { <------------- We need to try-catch these calls because they may fail in an unlikely case when we get an invalid UTF-8 string,
+//     final strPtr = txid.cast<Utf8>();                                            it is better to throw than to crash main isolate imo.
+//     final str = strPtr.toDartString(); <------------- convert the pointer to const char* to dart String
+//     MONERO_free(strPtr.cast()); <------------- free the memory
+//     debugEnd?.call('MONERO_PendingTransaction_txid');
+//     return str; <------------- return the value
+//   } catch (e) {
+//     errorHandler?.call('MONERO_PendingTransaction_txid', e);
+//     debugEnd?.call('MONERO_PendingTransaction_txid');
+//     return ""; <------------- return an empty string in case of an error.
+//   }
+// }
+//
+
+// ignore_for_file: non_constant_identifier_names, camel_case_types
+
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:ffi/ffi.dart';
+import 'package:monero/src/generated_bindings_monero.g.dart';
+
+typedef PendingTransaction = Pointer<Void>;
+
+MoneroC? lib;
+String libPath = (() {
+  if (Platform.isWindows) return 'monero_libwallet2_api_c.dll';
+  if (Platform.isMacOS) return 'monero_libwallet2_api_c.dylib';
+  if (Platform.isIOS) return 'MoneroWallet.framework/MoneroWallet';
+  if (Platform.isAndroid) return 'libmonero_libwallet2_api_c.so';
+  return 'monero_libwallet2_api_c.so';
+})();
+
+Map<String, List<int>> debugCallLength = {};
+
+final defaultSeparatorStr = ";";
+final defaultSeparator = defaultSeparatorStr.toNativeUtf8().cast<Char>();
+/* we don't call .free here, this comment serves one purpose - so the numbers match :) */
+
+final Stopwatch sw = Stopwatch()..start();
+
+bool printStarts = false;
+
+void Function(String call)? debugStart = (call) {
+  if (printStarts) print("MONERO: $call");
+  debugCallLength[call] ??= <int>[];
+  debugCallLength[call]!.add(sw.elapsedMicroseconds);
+};
+void Function(String call)? debugEnd = (call) {
+  final id = debugCallLength[call]!.length - 1;
+  debugCallLength[call]![id] =
+      sw.elapsedMicroseconds - debugCallLength[call]![id];
+};
+void Function(String call, dynamic error)? errorHandler = (call, error) {
+  print("$call: $error");
+};
+
+int PendingTransaction_status(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_status');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_PendingTransaction_status(ptr);
+  debugEnd?.call('MONERO_PendingTransaction_status');
+  return status;
+}
+
+String PendingTransaction_errorString(PendingTransaction ptr) {
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  debugStart?.call('MONERO_PendingTransaction_errorString');
+  try {
+    final rPtr = lib!.MONERO_PendingTransaction_errorString(ptr).cast<Utf8>();
+    final str = rPtr.toDartString();
+    MONERO_free(rPtr.cast());
+    debugEnd?.call('MONERO_PendingTransaction_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_errorString', e);
+    debugEnd?.call('MONERO_PendingTransaction_errorString');
+    return "";
+  }
+}
+
+bool PendingTransaction_commit(PendingTransaction ptr,
+    {required String filename, required bool overwrite}) {
+  debugStart?.call('MONERO_PendingTransaction_commit');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final result =
+      lib!.MONERO_PendingTransaction_commit(ptr, filename_, overwrite);
+  calloc.free(filename_);
+  debugEnd?.call('MONERO_PendingTransaction_commit');
+  return result;
+}
+
+String PendingTransaction_commitUR(
+    PendingTransaction ptr, int max_fragment_length) {
+  debugStart?.call('MONERO_PendingTransaction_commitUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txid =
+      lib!.MONERO_PendingTransaction_commitUR(ptr, max_fragment_length);
+  debugEnd?.call('MONERO_PendingTransaction_commitUR');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_PendingTransaction_commitUR');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_commitUR', e);
+    debugEnd?.call('MONERO_PendingTransaction_commitUR');
+    return "";
+  }
+}
+
+int PendingTransaction_amount(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_amount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final amount = lib!.MONERO_PendingTransaction_amount(ptr);
+  debugStart?.call('MONERO_PendingTransaction_amount');
+  return amount;
+}
+
+int PendingTransaction_dust(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_dust');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final dust = lib!.MONERO_PendingTransaction_dust(ptr);
+  debugStart?.call('MONERO_PendingTransaction_dust');
+  return dust;
+}
+
+int PendingTransaction_fee(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_fee');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final fee = lib!.MONERO_PendingTransaction_fee(ptr);
+  debugEnd?.call('MONERO_PendingTransaction_fee');
+  return fee;
+}
+
+String PendingTransaction_txid(PendingTransaction ptr, String separator) {
+  debugStart?.call('MONERO_PendingTransaction_txid');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.MONERO_PendingTransaction_txid(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('MONERO_PendingTransaction_txid');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_PendingTransaction_txid');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_txid', e);
+    debugEnd?.call('MONERO_PendingTransaction_txid');
+    return "";
+  }
+}
+
+int PendingTransaction_txCount(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_txCount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txCount = lib!.MONERO_PendingTransaction_txCount(ptr);
+  debugEnd?.call('MONERO_PendingTransaction_txCount');
+  return txCount;
+}
+
+String PendingTransaction_subaddrAccount(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('MONERO_PendingTransaction_subaddrAccount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.MONERO_PendingTransaction_subaddrAccount(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('MONERO_PendingTransaction_subaddrAccount');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_PendingTransaction_subaddrAccount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_subaddrAccount', e);
+    debugEnd?.call('MONERO_PendingTransaction_subaddrAccount');
+    return "";
+  }
+}
+
+String PendingTransaction_subaddrIndices(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('MONERO_PendingTransaction_subaddrIndices');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.MONERO_PendingTransaction_subaddrIndices(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('MONERO_PendingTransaction_subaddrIndices');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_PendingTransaction_subaddrIndices');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_subaddrIndices', e);
+    debugEnd?.call('MONERO_PendingTransaction_subaddrIndices');
+    return "";
+  }
+}
+
+String PendingTransaction_multisigSignData(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_multisigSignData');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txid = lib!.MONERO_PendingTransaction_multisigSignData(ptr);
+  debugEnd?.call('MONERO_PendingTransaction_multisigSignData');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_PendingTransaction_multisigSignData');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_multisigSignData', e);
+    debugEnd?.call('MONERO_PendingTransaction_multisigSignData');
+    return "";
+  }
+}
+
+void PendingTransaction_signMultisigTx(PendingTransaction ptr) {
+  debugStart?.call('MONERO_PendingTransaction_signMultisigTx');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_PendingTransaction_signMultisigTx(ptr);
+  debugEnd?.call('MONERO_PendingTransaction_signMultisigTx');
+  return ret;
+}
+
+String PendingTransaction_signersKeys(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('MONERO_PendingTransaction_signersKeys');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.MONERO_PendingTransaction_signersKeys(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('MONERO_PendingTransaction_signersKeys');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    debugEnd?.call('MONERO_PendingTransaction_signersKeys');
+    MONERO_free(strPtr.cast());
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_signersKeys', e);
+    debugEnd?.call('MONERO_PendingTransaction_signersKeys');
+    return "";
+  }
+}
+
+String PendingTransaction_hex(PendingTransaction ptr, String separator) {
+  debugStart?.call('MONERO_PendingTransaction_hex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.MONERO_PendingTransaction_hex(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('MONERO_PendingTransaction_hex');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    debugEnd?.call('MONERO_PendingTransaction_hex');
+    MONERO_free(strPtr.cast());
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_PendingTransaction_hex', e);
+    debugEnd?.call('MONERO_PendingTransaction_hex');
+    return "";
+  }
+}
+
+// UnsignedTransaction
+
+typedef UnsignedTransaction = Pointer<Void>;
+
+int UnsignedTransaction_status(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_status');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final dust = lib!.MONERO_UnsignedTransaction_status(ptr);
+  debugStart?.call('MONERO_UnsignedTransaction_status');
+  return dust;
+}
+
+String UnsignedTransaction_errorString(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_errorString');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString = lib!.MONERO_UnsignedTransaction_errorString(ptr);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_errorString', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_errorString');
+    return "";
+  }
+}
+
+String UnsignedTransaction_amount(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_amount');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.MONERO_UnsignedTransaction_amount(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_amount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_amount', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_amount');
+    return "";
+  }
+}
+
+String UnsignedTransaction_fee(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_fee');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.MONERO_UnsignedTransaction_fee(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_fee');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_fee', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_fee');
+    return "";
+  }
+}
+
+String UnsignedTransaction_mixin(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_mixin');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.MONERO_UnsignedTransaction_mixin(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_mixin');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_mixin', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_mixin');
+    return "";
+  }
+}
+
+String UnsignedTransaction_confirmationMessage(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_confirmationMessage');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString = lib!.MONERO_UnsignedTransaction_confirmationMessage(ptr);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_confirmationMessage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_confirmationMessage', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_confirmationMessage');
+    return "";
+  }
+}
+
+String UnsignedTransaction_paymentId(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_paymentId');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.MONERO_UnsignedTransaction_paymentId(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_paymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_paymentId', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_paymentId');
+    return "";
+  }
+}
+
+String UnsignedTransaction_recipientAddress(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_recipientAddress');
+
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.MONERO_UnsignedTransaction_recipientAddress(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_recipientAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_recipientAddress', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_recipientAddress');
+    return "";
+  }
+}
+
+int UnsignedTransaction_minMixinCount(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_minMixinCount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_UnsignedTransaction_minMixinCount(ptr);
+  debugStart?.call('MONERO_UnsignedTransaction_minMixinCount');
+  return v;
+}
+
+int UnsignedTransaction_txCount(UnsignedTransaction ptr) {
+  debugStart?.call('MONERO_UnsignedTransaction_txCount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_UnsignedTransaction_txCount(ptr);
+  debugStart?.call('MONERO_UnsignedTransaction_txCount');
+  return v;
+}
+
+bool UnsignedTransaction_sign(UnsignedTransaction ptr, String signedFileName) {
+  debugStart?.call('MONERO_UnsignedTransaction_sign');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final signedFileName_ = signedFileName.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_UnsignedTransaction_sign(ptr, signedFileName_);
+  calloc.free(signedFileName_);
+  debugStart?.call('MONERO_UnsignedTransaction_sign');
+  return v;
+}
+
+String UnsignedTransaction_signUR(
+    PendingTransaction ptr, int max_fragment_length) {
+  debugStart?.call('MONERO_UnsignedTransaction_signUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txid = lib!.MONERO_UnsignedTransaction_signUR(ptr, max_fragment_length);
+  debugEnd?.call('MONERO_UnsignedTransaction_signUR');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_UnsignedTransaction_signUR');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_UnsignedTransaction_signUR', e);
+    debugEnd?.call('MONERO_UnsignedTransaction_signUR');
+    return "";
+  }
+}
+
+// TransactionInfo
+
+typedef TransactionInfo = Pointer<Void>;
+
+enum TransactionInfo_Direction { In, Out }
+
+TransactionInfo_Direction TransactionInfo_direction(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_direction');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final tiDir = TransactionInfo_Direction
+      .values[lib!.MONERO_TransactionInfo_direction(ptr)];
+  debugEnd?.call('MONERO_TransactionInfo_direction');
+  return tiDir;
+}
+
+bool TransactionInfo_isPending(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_isPending');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final isPending = lib!.MONERO_TransactionInfo_isPending(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_isPending');
+
+  return isPending;
+}
+
+bool TransactionInfo_isFailed(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_isFailed');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final isFailed = lib!.MONERO_TransactionInfo_isFailed(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_isFailed');
+  return isFailed;
+}
+
+bool TransactionInfo_isCoinbase(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_isCoinbase');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final isCoinbase = lib!.MONERO_TransactionInfo_isCoinbase(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_isCoinbase');
+  return isCoinbase;
+}
+
+int TransactionInfo_amount(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_amount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final amount = lib!.MONERO_TransactionInfo_amount(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_amount');
+  return amount;
+}
+
+int TransactionInfo_fee(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_fee');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final fee = lib!.MONERO_TransactionInfo_fee(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_fee');
+  return fee;
+}
+
+int TransactionInfo_blockHeight(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_blockHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final blockHeight = lib!.MONERO_TransactionInfo_blockHeight(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_blockHeight');
+  return blockHeight;
+}
+
+String TransactionInfo_description(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_description');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_TransactionInfo_description(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_TransactionInfo_description');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_TransactionInfo_description', e);
+    return "";
+  }
+}
+
+String TransactionInfo_subaddrIndex(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_subaddrIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_TransactionInfo_subaddrIndex(ptr, defaultSeparator)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_TransactionInfo_subaddrIndex');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_TransactionInfo_subaddrIndex', e);
+    return "";
+  }
+}
+
+int TransactionInfo_subaddrAccount(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_subaddrAccount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final subaddrAccount = lib!.MONERO_TransactionInfo_subaddrAccount(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_subaddrAccount');
+  return subaddrAccount;
+}
+
+String TransactionInfo_label(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_label');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_TransactionInfo_label(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_TransactionInfo_label');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_TransactionInfo_label', e);
+    debugEnd?.call('MONERO_TransactionInfo_label');
+    return "";
+  }
+}
+
+int TransactionInfo_confirmations(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_confirmations');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final confirmations = lib!.MONERO_TransactionInfo_confirmations(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_confirmations');
+  return confirmations;
+}
+
+int TransactionInfo_unlockTime(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_unlockTime');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final unlockTime = lib!.MONERO_TransactionInfo_unlockTime(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_unlockTime');
+  return unlockTime;
+}
+
+String TransactionInfo_hash(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_hash');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_TransactionInfo_hash(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_TransactionInfo_hash');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_TransactionInfo_hash', e);
+    debugEnd?.call('MONERO_TransactionInfo_hash');
+    return "";
+  }
+}
+
+int TransactionInfo_timestamp(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_timestamp');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final timestamp = lib!.MONERO_TransactionInfo_timestamp(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_timestamp');
+  return timestamp;
+}
+
+String TransactionInfo_paymentId(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_paymentId');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_TransactionInfo_paymentId(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_TransactionInfo_paymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_TransactionInfo_paymentId', e);
+    debugEnd?.call('MONERO_TransactionInfo_paymentId');
+    return "";
+  }
+}
+
+int TransactionInfo_transfers_count(TransactionInfo ptr) {
+  debugStart?.call('MONERO_TransactionInfo_transfers_count');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_TransactionInfo_transfers_count(ptr);
+  debugEnd?.call('MONERO_TransactionInfo_transfers_count');
+  return v;
+}
+
+int TransactionInfo_transfers_amount(TransactionInfo ptr, int index) {
+  debugStart?.call('MONERO_TransactionInfo_transfers_amount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_TransactionInfo_transfers_amount(ptr, index);
+  debugEnd?.call('MONERO_TransactionInfo_transfers_amount');
+  return v;
+}
+
+String TransactionInfo_transfers_address(TransactionInfo ptr, int index) {
+  debugStart?.call('MONERO_TransactionInfo_transfers_address');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_TransactionInfo_transfers_address(ptr, index).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_TransactionInfo_transfers_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_TransactionInfo_transfers_address', e);
+    debugEnd?.call('MONERO_TransactionInfo_transfers_address');
+    return "";
+  }
+}
+
+// TransactionHistory
+
+typedef TransactionHistory = Pointer<Void>;
+
+int TransactionHistory_count(TransactionHistory txHistory_ptr) {
+  debugStart?.call('MONERO_TransactionHistory_count');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final count = lib!.MONERO_TransactionHistory_count(txHistory_ptr);
+  debugEnd?.call('MONERO_TransactionHistory_count');
+  return count;
+}
+
+TransactionInfo TransactionHistory_transaction(TransactionHistory txHistory_ptr,
+    {required int index}) {
+  debugStart?.call('MONERO_TransactionHistory_transaction');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final transaction =
+      lib!.MONERO_TransactionHistory_transaction(txHistory_ptr, index);
+  debugEnd?.call('MONERO_TransactionHistory_transaction');
+  return transaction;
+}
+
+TransactionInfo TransactionHistory_transactionById(
+    TransactionHistory txHistory_ptr,
+    {required String txid}) {
+  debugStart?.call('MONERO_TransactionHistory_transactionById');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final transaction =
+      lib!.MONERO_TransactionHistory_transactionById(txHistory_ptr, txid_);
+  calloc.free(txid_);
+  debugEnd?.call('MONERO_TransactionHistory_transactionById');
+  return transaction;
+}
+
+void TransactionHistory_refresh(TransactionHistory txHistory_ptr) {
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  return lib!.MONERO_TransactionHistory_refresh(txHistory_ptr);
+}
+
+void TransactionHistory_setTxNote(TransactionHistory txHistory_ptr,
+    {required String txid, required String note}) {
+  debugStart?.call('MONERO_TransactionHistory_setTxNote');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final note_ = note.toNativeUtf8().cast<Char>();
+  final s =
+      lib!.MONERO_TransactionHistory_setTxNote(txHistory_ptr, txid_, note_);
+  calloc.free(txid_);
+  calloc.free(note_);
+  debugEnd?.call('MONERO_TransactionHistory_setTxNote');
+  return s;
+}
+
+// AddresBookRow
+
+typedef AddressBookRow = Pointer<Void>;
+
+String AddressBookRow_extra(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_AddressBookRow_extra');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_AddressBookRow_extra(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_AddressBookRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_AddressBookRow_extra', e);
+    debugEnd?.call('MONERO_AddressBookRow_extra');
+    return "";
+  }
+}
+
+String AddressBookRow_getAddress(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_AddressBookRow_getAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_AddressBookRow_getAddress(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_AddressBookRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_AddressBookRow_getAddress', e);
+    debugEnd?.call('MONERO_AddressBookRow_getAddress');
+    return "";
+  }
+}
+
+String AddressBookRow_getDescription(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_AddressBookRow_getDescription');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_AddressBookRow_getDescription(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_AddressBookRow_getDescription');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_AddressBookRow_getDescription', e);
+    debugEnd?.call('MONERO_AddressBookRow_getDescription');
+    return "";
+  }
+}
+
+String AddressBookRow_getPaymentId(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_AddressBookRow_getPaymentId');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_AddressBookRow_getPaymentId(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_AddressBookRow_getPaymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_AddressBookRow_getPaymentId', e);
+    debugEnd?.call('MONERO_AddressBookRow_getPaymentId');
+    return "";
+  }
+}
+
+int AddressBookRow_getRowId(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_AddressBookRow_getRowId');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_AddressBookRow_getRowId(addressBookRow_ptr);
+  debugEnd?.call('MONERO_AddressBookRow_getRowId');
+  return v;
+}
+
+// AddressBook
+
+typedef AddressBook = Pointer<Void>;
+
+int AddressBook_getAll_size(AddressBook addressBook_ptr) {
+  debugStart?.call('MONERO_AddressBook_getAll_size');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_AddressBook_getAll_size(addressBook_ptr);
+  debugEnd?.call('MONERO_AddressBook_getAll_size');
+  return v;
+}
+
+AddressBookRow AddressBook_getAll_byIndex(AddressBook addressBook_ptr,
+    {required int index}) {
+  debugStart?.call('MONERO_AddressBook_getAll_byIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_AddressBook_getAll_byIndex(addressBook_ptr, index);
+  debugEnd?.call('MONERO_AddressBook_getAll_byIndex');
+  return v;
+}
+
+bool AddressBook_addRow(
+  AddressBook addressBook_ptr, {
+  required String dstAddr,
+  required String paymentId,
+  required String description,
+}) {
+  debugStart?.call('MONERO_AddressBook_addRow');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final dst_addr_ = dstAddr.toNativeUtf8().cast<Char>();
+  final payment_id_ = paymentId.toNativeUtf8().cast<Char>();
+  final description_ = description.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_AddressBook_addRow(
+      addressBook_ptr, dst_addr_, payment_id_, description_);
+  calloc.free(dst_addr_);
+  calloc.free(payment_id_);
+  calloc.free(description_);
+  debugEnd?.call('MONERO_AddressBook_addRow');
+  return v;
+}
+
+bool AddressBook_deleteRow(AddressBook addressBook_ptr, {required int rowId}) {
+  debugStart?.call('MONERO_AddressBook_deleteRow');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_AddressBook_deleteRow(addressBook_ptr, rowId);
+  debugEnd?.call('MONERO_AddressBook_deleteRow');
+  return v;
+}
+
+bool AddressBook_setDescription(
+  AddressBook addressBook_ptr, {
+  required int rowId,
+  required String description,
+}) {
+  debugStart?.call('MONERO_AddressBook_setDescription');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final description_ = description.toNativeUtf8().cast<Char>();
+  final v = lib!
+      .MONERO_AddressBook_setDescription(addressBook_ptr, rowId, description_);
+  calloc.free(description_);
+  debugEnd?.call('MONERO_AddressBook_setDescription');
+  return v;
+}
+
+void AddressBook_refresh(AddressBook addressBook_ptr) {
+  debugStart?.call('MONERO_AddressBook_refresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_AddressBook_refresh(addressBook_ptr);
+  debugEnd?.call('MONERO_AddressBook_refresh');
+  return v;
+}
+
+int AddressBook_errorCode(AddressBook addressBook_ptr) {
+  debugStart?.call('MONERO_AddressBook_errorCode');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_AddressBook_errorCode(addressBook_ptr);
+  debugEnd?.call('MONERO_AddressBook_errorCode');
+  return v;
+}
+
+int AddressBook_lookupPaymentID(AddressBook addressBook_ptr,
+    {required String paymentId}) {
+  debugStart?.call('MONERO_AddressBook_lookupPaymentID');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+  final v =
+      lib!.MONERO_AddressBook_lookupPaymentID(addressBook_ptr, paymentId_);
+  calloc.free(paymentId_);
+  debugEnd?.call('MONERO_AddressBook_lookupPaymentID');
+  return v;
+}
+
+// CoinsInfo
+typedef CoinsInfo = Pointer<Void>;
+
+int CoinsInfo_blockHeight(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_blockHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_blockHeight(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_blockHeight');
+  return v;
+}
+
+String CoinsInfo_hash(CoinsInfo addressBookRow_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_hash');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_CoinsInfo_hash(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_CoinsInfo_hash');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_CoinsInfo_hash', e);
+    debugEnd?.call('MONERO_CoinsInfo_hash');
+    return "";
+  }
+}
+
+int CoinsInfo_internalOutputIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_internalOutputIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_internalOutputIndex(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_internalOutputIndex');
+  return v;
+}
+
+int CoinsInfo_globalOutputIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_globalOutputIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_globalOutputIndex(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_globalOutputIndex');
+  return v;
+}
+
+bool CoinsInfo_spent(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_spent');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_spent(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_spent');
+  return v;
+}
+
+bool CoinsInfo_frozen(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_frozen');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_frozen(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_frozen');
+  return v;
+}
+
+int CoinsInfo_spentHeight(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_spentHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_spentHeight(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_spentHeight');
+  return v;
+}
+
+int CoinsInfo_amount(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_amount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_amount(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_amount');
+  return v;
+}
+
+bool CoinsInfo_rct(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_rct');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_rct(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_rct');
+  return v;
+}
+
+bool CoinsInfo_keyImageKnown(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_keyImageKnown');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_keyImageKnown(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_keyImageKnown');
+  return v;
+}
+
+int CoinsInfo_pkIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_pkIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_pkIndex(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_pkIndex');
+  return v;
+}
+
+int CoinsInfo_subaddrIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_subaddrIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_subaddrIndex(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_subaddrIndex');
+  return v;
+}
+
+int CoinsInfo_subaddrAccount(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_subaddrAccount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_subaddrAccount(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_subaddrAccount');
+  return v;
+}
+
+String CoinsInfo_address(CoinsInfo addressBookRow_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_address');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_CoinsInfo_address(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_CoinsInfo_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_CoinsInfo_address', e);
+    debugEnd?.call('MONERO_CoinsInfo_address');
+    return "";
+  }
+}
+
+String CoinsInfo_addressLabel(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_addressLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_CoinsInfo_addressLabel(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_CoinsInfo_addressLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_CoinsInfo_addressLabel', e);
+    debugEnd?.call('MONERO_CoinsInfo_addressLabel');
+    return "";
+  }
+}
+
+String CoinsInfo_keyImage(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_keyImage');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_CoinsInfo_keyImage(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_CoinsInfo_keyImage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_CoinsInfo_keyImage', e);
+    debugEnd?.call('MONERO_CoinsInfo_keyImage');
+    return "";
+  }
+}
+
+int CoinsInfo_unlockTime(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_unlockTime');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_unlockTime(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_unlockTime');
+  return v;
+}
+
+bool CoinsInfo_unlocked(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_unlocked');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_unlocked(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_unlocked');
+  return v;
+}
+
+String CoinsInfo_pubKey(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_pubKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_CoinsInfo_pubKey(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_CoinsInfo_pubKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_CoinsInfo_pubKey', e);
+    debugEnd?.call('MONERO_CoinsInfo_pubKey');
+    return "";
+  }
+}
+
+bool CoinsInfo_coinbase(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_coinbase');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_CoinsInfo_coinbase(coinsInfo_ptr);
+  debugEnd?.call('MONERO_CoinsInfo_coinbase');
+  return v;
+}
+
+String CoinsInfo_description(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('MONERO_CoinsInfo_description');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_CoinsInfo_description(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_CoinsInfo_description');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_CoinsInfo_description', e);
+    debugEnd?.call('MONERO_CoinsInfo_description');
+    return "";
+  }
+}
+
+typedef Coins = Pointer<Void>;
+
+int Coins_count(Coins coins_ptr) {
+  debugStart?.call('MONERO_Coins_count');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_count(coins_ptr);
+  debugEnd?.call('MONERO_Coins_count');
+  return v;
+}
+
+CoinsInfo Coins_coin(Coins coins_ptr, int index) {
+  debugStart?.call('MONERO_Coins_coin');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_coin(coins_ptr, index);
+  debugEnd?.call('MONERO_Coins_coin');
+  return v;
+}
+
+int Coins_getAll_size(Coins coins_ptr) {
+  debugStart?.call('MONERO_Coins_getAll_size');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_getAll_size(coins_ptr);
+  debugEnd?.call('MONERO_Coins_getAll_size');
+  return v;
+}
+
+CoinsInfo Coins_getAll_byIndex(Coins coins_ptr, int index) {
+  debugStart?.call('MONERO_Coins_getAll_byIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_getAll_byIndex(coins_ptr, index);
+  debugEnd?.call('MONERO_Coins_getAll_byIndex');
+  return v;
+}
+
+void Coins_refresh(Coins coins_ptr) {
+  debugStart?.call('MONERO_Coins_refresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_refresh(coins_ptr);
+  debugEnd?.call('MONERO_Coins_refresh');
+  return v;
+}
+
+void Coins_setFrozenByPublicKey(Coins coins_ptr, {required String publicKey}) {
+  debugStart?.call('MONERO_Coins_setFrozenByPublicKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final publicKey_ = publicKey.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_Coins_setFrozenByPublicKey(coins_ptr, publicKey_);
+  calloc.free(publicKey_);
+  debugEnd?.call('MONERO_Coins_setFrozenByPublicKey');
+  return v;
+}
+
+void Coins_setFrozen(Coins coins_ptr, {required int index}) {
+  debugStart?.call('MONERO_Coins_setFrozen');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_setFrozen(coins_ptr, index);
+  debugEnd?.call('MONERO_Coins_setFrozen');
+  return v;
+}
+
+void Coins_thaw(Coins coins_ptr, {required int index}) {
+  debugStart?.call('MONERO_Coins_thaw');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Coins_thaw(coins_ptr, index);
+  debugEnd?.call('MONERO_Coins_thaw');
+  return v;
+}
+
+void Coins_thawByPublicKey(Coins coins_ptr, {required String publicKey}) {
+  debugStart?.call('MONERO_Coins_thawByPublicKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final publicKey_ = publicKey.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_Coins_thawByPublicKey(coins_ptr, publicKey_);
+  calloc.free(publicKey_);
+  debugEnd?.call('MONERO_Coins_thawByPublicKey');
+  return v;
+}
+
+bool Coins_isTransferUnlocked(
+  Coins coins_ptr, {
+  required int unlockTime,
+  required int blockHeight,
+}) {
+  debugStart?.call('MONERO_Coins_isTransferUnlocked');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v =
+      lib!.MONERO_Coins_isTransferUnlocked(coins_ptr, unlockTime, blockHeight);
+  debugEnd?.call('MONERO_Coins_isTransferUnlocked');
+  return v;
+}
+
+// SubaddressRow
+
+typedef SubaddressRow = Pointer<Void>;
+
+String SubaddressRow_extra(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressRow_extra');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_SubaddressRow_extra(subaddressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressRow_extra', e);
+    debugEnd?.call('MONERO_SubaddressRow_extra');
+    return "";
+  }
+}
+
+String SubaddressRow_getAddress(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressRow_getAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_SubaddressRow_getAddress(subaddressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressRow_getAddress', e);
+    debugEnd?.call('MONERO_SubaddressRow_getAddress');
+    return "";
+  }
+}
+
+String SubaddressRow_getLabel(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressRow_getLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_SubaddressRow_getLabel(subaddressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressRow_getLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressRow_getLabel', e);
+    debugEnd?.call('MONERO_SubaddressRow_getLabel');
+    return "";
+  }
+}
+
+int SubaddressRow_getRowId(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressRow_getRowId');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_SubaddressRow_getRowId(subaddressBookRow_ptr);
+  debugEnd?.call('MONERO_SubaddressRow_getRowId');
+  return status;
+}
+
+// Subaddress
+
+typedef Subaddress = Pointer<Void>;
+
+int Subaddress_getAll_size(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('MONERO_Subaddress_getAll_size');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Subaddress_getAll_size(subaddressBookRow_ptr);
+  debugEnd?.call('MONERO_Subaddress_getAll_size');
+  return status;
+}
+
+SubaddressRow Subaddress_getAll_byIndex(Subaddress subaddressRow_ptr,
+    {required int index}) {
+  debugStart?.call('MONERO_Subaddress_getAll_byIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.MONERO_Subaddress_getAll_byIndex(subaddressRow_ptr, index);
+  debugEnd?.call('MONERO_Subaddress_getAll_byIndex');
+  return status;
+}
+
+void Subaddress_addRow(Subaddress ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('MONERO_Subaddress_addRow');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.MONERO_Subaddress_addRow(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_Subaddress_addRow');
+  return status;
+}
+
+void Subaddress_setLabel(Subaddress ptr,
+    {required int accountIndex,
+    required int addressIndex,
+    required String label}) {
+  debugStart?.call('MONERO_Subaddress_setLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status =
+      lib!.MONERO_Subaddress_setLabel(ptr, accountIndex, addressIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_Subaddress_setLabel');
+  return status;
+}
+
+void Subaddress_refresh(Subaddress ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('MONERO_Subaddress_refresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.MONERO_Subaddress_refresh(ptr, accountIndex);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_Subaddress_refresh');
+  return status;
+}
+
+typedef SubaddressAccountRow = Pointer<Void>;
+
+String SubaddressAccountRow_extra(SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressAccountRow_extra');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.MONERO_SubaddressAccountRow_extra(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressAccountRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressAccountRow_extra', e);
+    debugEnd?.call('MONERO_SubaddressAccountRow_extra');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getAddress(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressAccountRow_getAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_SubaddressAccountRow_getAddress(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressAccountRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressAccountRow_getAddress', e);
+    debugEnd?.call('MONERO_SubaddressAccountRow_getAddress');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getLabel(SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressAccountRow_getLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_SubaddressAccountRow_getLabel(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressAccountRow_getLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressAccountRow_getLabel', e);
+    debugEnd?.call('MONERO_SubaddressAccountRow_getLabel');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getBalance(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressAccountRow_getBalance');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_SubaddressAccountRow_getBalance(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressAccountRow_getBalance');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressAccountRow_getBalance', e);
+    debugEnd?.call('MONERO_SubaddressAccountRow_getBalance');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getUnlockedBalance(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('MONERO_SubaddressAccountRow_getUnlockedBalance');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_SubaddressAccountRow_getUnlockedBalance(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_SubaddressAccountRow_getUnlockedBalance');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_SubaddressAccountRow_getUnlockedBalance', e);
+    debugEnd?.call('MONERO_SubaddressAccountRow_getUnlockedBalance');
+    return "";
+  }
+}
+
+int SubaddressAccountRow_getRowId(SubaddressAccountRow ptr) {
+  debugStart?.call('MONERO_SubaddressAccountRow_getRowId');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_SubaddressAccountRow_getRowId(ptr);
+  debugEnd?.call('MONERO_SubaddressAccountRow_getRowId');
+  return status;
+}
+
+typedef SubaddressAccount = Pointer<Void>;
+
+int SubaddressAccount_getAll_size(SubaddressAccount ptr) {
+  debugStart?.call('MONERO_SubaddressAccount_getAll_size');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_SubaddressAccount_getAll_size(ptr);
+  debugEnd?.call('MONERO_SubaddressAccount_getAll_size');
+  return status;
+}
+
+SubaddressAccountRow SubaddressAccount_getAll_byIndex(SubaddressAccount ptr,
+    {required int index}) {
+  debugStart?.call('MONERO_SubaddressAccount_getAll_byIndex');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_SubaddressAccount_getAll_byIndex(ptr, index);
+  debugEnd?.call('MONERO_SubaddressAccount_getAll_byIndex');
+  return status;
+}
+
+void SubaddressAccount_addRow(SubaddressAccount ptr, {required String label}) {
+  debugStart?.call('MONERO_SubaddressAccount_addRow');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.MONERO_SubaddressAccount_addRow(ptr, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_SubaddressAccount_addRow');
+  return status;
+}
+
+void SubaddressAccount_setLabel(SubaddressAccount ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('MONERO_SubaddressAccount_setLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status =
+      lib!.MONERO_SubaddressAccount_setLabel(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_SubaddressAccount_setLabel');
+  return status;
+}
+
+void SubaddressAccount_refresh(SubaddressAccount ptr) {
+  debugStart?.call('MONERO_SubaddressAccount_refresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_SubaddressAccount_refresh(ptr);
+  debugEnd?.call('MONERO_SubaddressAccount_refresh');
+  return status;
+}
+
+// MultisigState
+
+typedef MultisigState = Pointer<Void>;
+
+bool MultisigState_isMultisig(MultisigState ptr) {
+  debugStart?.call('MONERO_MultisigState_isMultisig');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_MultisigState_isMultisig(ptr);
+  debugEnd?.call('MONERO_MultisigState_isMultisig');
+  return status;
+}
+
+bool MultisigState_isReady(MultisigState ptr) {
+  debugStart?.call('MONERO_MultisigState_isReady');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_MultisigState_isReady(ptr);
+  debugEnd?.call('MONERO_MultisigState_isReady');
+  return status;
+}
+
+int MultisigState_threshold(MultisigState ptr) {
+  debugStart?.call('MONERO_MultisigState_threshold');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_MultisigState_threshold(ptr);
+  debugEnd?.call('MONERO_MultisigState_threshold');
+  return status;
+}
+
+int MultisigState_total(MultisigState ptr) {
+  debugStart?.call('MONERO_MultisigState_total');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_MultisigState_total(ptr);
+  debugEnd?.call('MONERO_MultisigState_total');
+  return status;
+}
+
+// DeviceProgress
+
+typedef DeviceProgress = Pointer<Void>;
+
+bool DeviceProgress_progress(DeviceProgress ptr) {
+  debugStart?.call('MONERO_DeviceProgress_progress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_DeviceProgress_progress(ptr);
+  debugEnd?.call('MONERO_DeviceProgress_progress');
+  return status;
+}
+
+bool DeviceProgress_indeterminate(DeviceProgress ptr) {
+  debugStart?.call('MONERO_DeviceProgress_indeterminate');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_DeviceProgress_indeterminate(ptr);
+  debugEnd?.call('MONERO_DeviceProgress_indeterminate');
+  return status;
+}
+// Wallet
+
+typedef wallet = Pointer<Void>;
+
+String Wallet_seed(wallet ptr, {required String seedOffset}) {
+  debugStart?.call('MONERO_Wallet_seed');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.MONERO_Wallet_seed(ptr, seedOffset_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(seedOffset_);
+    debugEnd?.call('MONERO_Wallet_seed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_seed', e);
+    debugEnd?.call('MONERO_Wallet_seed');
+    return "";
+  }
+}
+
+String Wallet_getSeedLanguage(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getSeedLanguage');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_getSeedLanguage(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_getSeedLanguage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getSeedLanguage', e);
+    debugEnd?.call('MONERO_Wallet_getSeedLanguage');
+    return "";
+  }
+}
+
+void Wallet_setSeedLanguage(wallet ptr, {required String language}) {
+  debugStart?.call('MONERO_Wallet_setSeedLanguage');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final status = lib!.MONERO_Wallet_setSeedLanguage(ptr, language_);
+  calloc.free(language_);
+  debugEnd?.call('MONERO_Wallet_setSeedLanguage');
+  return status;
+}
+
+int Wallet_status(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_status');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Wallet_status(ptr);
+  debugEnd?.call('MONERO_Wallet_status');
+  return status;
+}
+
+String Wallet_errorString(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_errorString');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_errorString(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_errorString', e);
+    debugEnd?.call('MONERO_Wallet_errorString');
+    return "";
+  }
+}
+
+bool Wallet_setPassword(wallet ptr, {required String password}) {
+  debugStart?.call('MONERO_Wallet_setPassword');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final status = lib!.MONERO_Wallet_setPassword(ptr, password_);
+  calloc.free(password_);
+  debugEnd?.call('MONERO_Wallet_setPassword');
+  return status;
+}
+
+String Wallet_getPassword(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getPassword');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_getPassword(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_getPassword');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getPassword', e);
+    debugEnd?.call('MONERO_Wallet_getPassword');
+    return "";
+  }
+}
+
+bool Wallet_setDevicePin(wallet ptr, {required String passphrase}) {
+  debugStart?.call('MONERO_Wallet_setDevicePin');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final passphrase_ = passphrase.toNativeUtf8().cast<Char>();
+  final status = lib!.MONERO_Wallet_setDevicePin(ptr, passphrase_);
+  calloc.free(passphrase_);
+  debugEnd?.call('MONERO_Wallet_setDevicePin');
+  return status;
+}
+
+String Wallet_address(wallet ptr,
+    {int accountIndex = 0, int addressIndex = 0}) {
+  debugStart?.call('MONERO_Wallet_address');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_Wallet_address(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_address', e);
+    debugEnd?.call('MONERO_Wallet_address');
+    return "";
+  }
+}
+
+String Wallet_path(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_path');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_path(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_path');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_path', e);
+    debugEnd?.call('MONERO_Wallet_path');
+    return "";
+  }
+}
+
+int Wallet_nettype(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_nettype');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Wallet_nettype(ptr);
+  debugEnd?.call('MONERO_Wallet_nettype');
+  return status;
+}
+
+int Wallet_useForkRules(
+  wallet ptr, {
+  required int version,
+  required int earlyBlocks,
+}) {
+  debugStart?.call('MONERO_Wallet_useForkRules');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Wallet_useForkRules(ptr, version, earlyBlocks);
+  debugEnd?.call('MONERO_Wallet_useForkRules');
+  return status;
+}
+
+String Wallet_integratedAddress(wallet ptr, {required String paymentId}) {
+  debugStart?.call('MONERO_Wallet_integratedAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.MONERO_Wallet_integratedAddress(ptr, paymentId_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_integratedAddress');
+    calloc.free(paymentId_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_integratedAddress', e);
+    debugEnd?.call('MONERO_Wallet_integratedAddress');
+    return "";
+  }
+}
+
+String Wallet_secretViewKey(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_secretViewKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_secretViewKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_secretViewKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_secretViewKey', e);
+    debugEnd?.call('MONERO_Wallet_secretViewKey');
+    return "";
+  }
+}
+
+String Wallet_publicViewKey(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_publicViewKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_publicViewKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_publicViewKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_publicViewKey', e);
+    debugEnd?.call('MONERO_Wallet_publicViewKey');
+    return "";
+  }
+}
+
+String Wallet_secretSpendKey(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_secretSpendKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_secretSpendKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_secretSpendKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_secretSpendKey', e);
+    debugEnd?.call('MONERO_Wallet_secretSpendKey');
+    return "";
+  }
+}
+
+String Wallet_publicSpendKey(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_publicSpendKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_publicSpendKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_publicSpendKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_publicSpendKey', e);
+    debugEnd?.call('MONERO_Wallet_publicSpendKey');
+    return "";
+  }
+}
+
+String Wallet_publicMultisigSignerKey(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_publicMultisigSignerKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_publicMultisigSignerKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_publicMultisigSignerKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_publicMultisigSignerKey', e);
+    debugEnd?.call('MONERO_Wallet_publicMultisigSignerKey');
+    return "";
+  }
+}
+
+void Wallet_stop(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_stop');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final stop = lib!.MONERO_Wallet_stop(ptr);
+  debugEnd?.call('MONERO_Wallet_stop');
+  return stop;
+}
+
+bool Wallet_store(wallet ptr, {String path = ""}) {
+  debugStart?.call('MONERO_Wallet_store');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_store(ptr, path_);
+  calloc.free(path_);
+  debugEnd?.call('MONERO_Wallet_store');
+  return s;
+}
+
+String Wallet_filename(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_filename');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_filename(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_filename');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_filename', e);
+    debugEnd?.call('MONERO_Wallet_filename');
+    return "";
+  }
+}
+
+String Wallet_keysFilename(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_keysFilename');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_keysFilename(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_keysFilename');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_keysFilename', e);
+    debugEnd?.call('MONERO_Wallet_keysFilename');
+    return "";
+  }
+}
+
+bool Wallet_init(
+  wallet ptr, {
+  required String daemonAddress,
+  int upperTransacationSizeLimit = 0,
+  String daemonUsername = "",
+  String daemonPassword = "",
+  bool useSsl = false,
+  bool lightWallet = false,
+  String proxyAddress = "",
+}) {
+  debugStart?.call('MONERO_Wallet_init');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final daemonAddress_ = daemonAddress.toNativeUtf8().cast<Char>();
+  final daemonUsername_ = daemonUsername.toNativeUtf8().cast<Char>();
+  final daemonPassword_ = daemonPassword.toNativeUtf8().cast<Char>();
+  final proxyAddress_ = proxyAddress.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_init(
+      ptr,
+      daemonAddress_,
+      upperTransacationSizeLimit,
+      daemonUsername_,
+      daemonPassword_,
+      useSsl,
+      lightWallet,
+      proxyAddress_);
+
+  calloc.free(daemonAddress_);
+  calloc.free(daemonUsername_);
+  calloc.free(daemonPassword_);
+  calloc.free(proxyAddress_);
+  debugEnd?.call('MONERO_Wallet_init');
+  return s;
+}
+
+bool Wallet_createWatchOnly(
+  wallet ptr, {
+  required String path,
+  required String password,
+  required String language,
+}) {
+  debugStart?.call('MONERO_Wallet_createWatchOnly');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final getRefreshFromBlockHeight =
+      lib!.MONERO_Wallet_createWatchOnly(ptr, path_, password_, language_);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('MONERO_Wallet_createWatchOnly');
+  return getRefreshFromBlockHeight;
+}
+
+void Wallet_setRefreshFromBlockHeight(wallet ptr,
+    {required int refresh_from_block_height}) {
+  debugStart?.call('MONERO_Wallet_setRefreshFromBlockHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!
+      .MONERO_Wallet_setRefreshFromBlockHeight(ptr, refresh_from_block_height);
+  debugEnd?.call('MONERO_Wallet_setRefreshFromBlockHeight');
+  return status;
+}
+
+int Wallet_getRefreshFromBlockHeight(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getRefreshFromBlockHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final getRefreshFromBlockHeight =
+      lib!.MONERO_Wallet_getRefreshFromBlockHeight(ptr);
+  debugEnd?.call('MONERO_Wallet_getRefreshFromBlockHeight');
+  return getRefreshFromBlockHeight;
+}
+
+void Wallet_setRecoveringFromSeed(wallet ptr,
+    {required bool recoveringFromSeed}) {
+  debugStart?.call('MONERO_Wallet_setRecoveringFromSeed');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.MONERO_Wallet_setRecoveringFromSeed(ptr, recoveringFromSeed);
+  debugEnd?.call('MONERO_Wallet_setRecoveringFromSeed');
+  return status;
+}
+
+void Wallet_setRecoveringFromDevice(wallet ptr,
+    {required bool recoveringFromDevice}) {
+  debugStart?.call('MONERO_Wallet_setRecoveringFromDevice');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.MONERO_Wallet_setRecoveringFromDevice(ptr, recoveringFromDevice);
+  debugEnd?.call('MONERO_Wallet_setRecoveringFromDevice');
+  return status;
+}
+
+void Wallet_setSubaddressLookahead(wallet ptr,
+    {required int major, required int minor}) {
+  debugStart?.call('MONERO_Wallet_setSubaddressLookahead');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Wallet_setSubaddressLookahead(ptr, major, minor);
+  debugEnd?.call('MONERO_Wallet_setSubaddressLookahead');
+  return status;
+}
+
+bool Wallet_connectToDaemon(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_connectToDaemon');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final connectToDaemon = lib!.MONERO_Wallet_connectToDaemon(ptr);
+  debugEnd?.call('MONERO_Wallet_connectToDaemon');
+  return connectToDaemon;
+}
+
+int Wallet_connected(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_connected');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final connected = lib!.MONERO_Wallet_connected(ptr);
+  debugEnd?.call('MONERO_Wallet_connected');
+  return connected;
+}
+
+void Wallet_setTrustedDaemon(wallet ptr, {required bool arg}) {
+  debugStart?.call('MONERO_Wallet_setTrustedDaemon');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Wallet_setTrustedDaemon(ptr, arg);
+  debugEnd?.call('MONERO_Wallet_setTrustedDaemon');
+  return status;
+}
+
+bool Wallet_trustedDaemon(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_trustedDaemon');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final status = lib!.MONERO_Wallet_trustedDaemon(ptr);
+  debugEnd?.call('MONERO_Wallet_trustedDaemon');
+  return status;
+}
+
+bool Wallet_setProxy(wallet ptr, {required String address}) {
+  debugStart?.call('MONERO_Wallet_setProxy');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_setProxy(ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('MONERO_Wallet_setProxy');
+  return s;
+}
+
+int Wallet_balance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('MONERO_Wallet_balance');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final balance = lib!.MONERO_Wallet_balance(ptr, accountIndex);
+  debugEnd?.call('MONERO_Wallet_balance');
+  return balance;
+}
+
+int Wallet_unlockedBalance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('MONERO_Wallet_unlockedBalance');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final unlockedBalance = lib!.MONERO_Wallet_unlockedBalance(ptr, accountIndex);
+  debugEnd?.call('MONERO_Wallet_unlockedBalance');
+  return unlockedBalance;
+}
+
+int Wallet_viewOnlyBalance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('MONERO_Wallet_viewOnlyBalance');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final unlockedBalance = lib!.MONERO_Wallet_viewOnlyBalance(ptr, accountIndex);
+  debugEnd?.call('MONERO_Wallet_viewOnlyBalance');
+  return unlockedBalance;
+}
+
+bool Wallet_watchOnly(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_watchOnly');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final watchOnly = lib!.MONERO_Wallet_watchOnly(ptr);
+  debugEnd?.call('MONERO_Wallet_watchOnly');
+  return watchOnly;
+}
+
+int Wallet_blockChainHeight(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_blockChainHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final blockChainHeight = lib!.MONERO_Wallet_blockChainHeight(ptr);
+  debugEnd?.call('MONERO_Wallet_blockChainHeight');
+  return blockChainHeight;
+}
+
+int Wallet_approximateBlockChainHeight(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_approximateBlockChainHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final approximateBlockChainHeight =
+      lib!.MONERO_Wallet_approximateBlockChainHeight(ptr);
+  debugEnd?.call('MONERO_Wallet_approximateBlockChainHeight');
+  return approximateBlockChainHeight;
+}
+
+int Wallet_estimateBlockChainHeight(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_estimateBlockChainHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final estimateBlockChainHeight =
+      lib!.MONERO_Wallet_estimateBlockChainHeight(ptr);
+  debugEnd?.call('MONERO_Wallet_estimateBlockChainHeight');
+  return estimateBlockChainHeight;
+}
+
+int Wallet_daemonBlockChainHeight(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_daemonBlockChainHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final daemonBlockChainHeight = lib!.MONERO_Wallet_daemonBlockChainHeight(ptr);
+  debugEnd?.call('MONERO_Wallet_daemonBlockChainHeight');
+  return daemonBlockChainHeight;
+}
+
+int Wallet_daemonBlockChainHeight_cached(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_daemonBlockChainHeight_cached');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final daemonBlockChainHeight =
+      lib!.MONERO_Wallet_daemonBlockChainHeight_cached(ptr);
+  debugEnd?.call('MONERO_Wallet_daemonBlockChainHeight_cached');
+  return daemonBlockChainHeight;
+}
+
+void Wallet_daemonBlockChainHeight_runThread(wallet ptr, int seconds) {
+  debugStart?.call('MONERO_Wallet_daemonBlockChainHeight_enableRefresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_daemonBlockChainHeight_runThread(ptr, seconds);
+  debugEnd?.call('MONERO_Wallet_daemonBlockChainHeight_enableRefresh');
+  return ret;
+}
+
+bool Wallet_synchronized(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_synchronized');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final synchronized = lib!.MONERO_Wallet_synchronized(ptr);
+  debugEnd?.call('MONERO_Wallet_synchronized');
+  return synchronized;
+}
+
+String Wallet_displayAmount(int amount) {
+  debugStart?.call('MONERO_Wallet_displayAmount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_displayAmount(amount).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_displayAmount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_displayAmount', e);
+    debugEnd?.call('MONERO_Wallet_displayAmount');
+    return "";
+  }
+}
+
+int Wallet_amountFromString(String amount) {
+  debugStart?.call('MONERO_Wallet_amountFromString');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final amount_ = amount.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_amountFromString(amount_);
+  calloc.free(amount_);
+  debugEnd?.call('MONERO_Wallet_amountFromString');
+  return s;
+}
+
+int Wallet_amountFromDouble(double amount) {
+  debugStart?.call('MONERO_Wallet_amountFromDouble');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_Wallet_amountFromDouble(amount);
+  debugEnd?.call('MONERO_Wallet_amountFromDouble');
+  return s;
+}
+
+String Wallet_genPaymentId() {
+  debugStart?.call('MONERO_Wallet_genPaymentId');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_genPaymentId().cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_genPaymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_genPaymentId', e);
+    debugEnd?.call('MONERO_Wallet_genPaymentId');
+    return "";
+  }
+}
+
+bool Wallet_paymentIdValid(String paymentId) {
+  debugStart?.call('MONERO_Wallet_paymentIdValid');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_paymentIdValid(paymentId_);
+  calloc.free(paymentId_);
+  debugEnd?.call('MONERO_Wallet_paymentIdValid');
+  return s;
+}
+
+bool Wallet_addressValid(String address, int networkType) {
+  debugStart?.call('MONERO_Wallet_addressValid');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_addressValid(address_, networkType);
+  calloc.free(address_);
+  debugEnd?.call('MONERO_Wallet_addressValid');
+  return s;
+}
+
+bool Wallet_keyValid(
+    {required String secret_key_string,
+    required String address_string,
+    required bool isViewKey,
+    required int nettype}) {
+  debugStart?.call('MONERO_Wallet_keyValid');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final secret_key_string_ = secret_key_string.toNativeUtf8().cast<Char>();
+  final address_string_ = address_string.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_keyValid(
+      secret_key_string_, address_string_, isViewKey, nettype);
+  calloc.free(secret_key_string_);
+  calloc.free(address_string_);
+  debugEnd?.call('MONERO_Wallet_keyValid');
+  return s;
+}
+
+String Wallet_keyValid_error(
+    {required String secret_key_string,
+    required String address_string,
+    required bool isViewKey,
+    required int nettype}) {
+  debugStart?.call('MONERO_Wallet_keyValid_error');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final secret_key_string_ = secret_key_string.toNativeUtf8().cast<Char>();
+    final address_string_ = address_string.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .MONERO_Wallet_keyValid_error(
+            secret_key_string_, address_string_, isViewKey, nettype)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(secret_key_string_);
+    calloc.free(address_string_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_keyValid_error', e);
+    debugEnd?.call('MONERO_Wallet_keyValid_error');
+    return "";
+  }
+}
+
+String Wallet_paymentIdFromAddress(
+    {required String strarg, required int nettype}) {
+  debugStart?.call('MONERO_Wallet_paymentIdFromAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strarg_ = strarg.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.MONERO_Wallet_paymentIdFromAddress(strarg_, nettype).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(strarg_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_paymentIdFromAddress', e);
+    debugEnd?.call('MONERO_Wallet_paymentIdFromAddress');
+    return "";
+  }
+}
+
+int Wallet_maximumAllowedAmount() {
+  debugStart?.call('MONERO_Wallet_maximumAllowedAmount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_Wallet_maximumAllowedAmount();
+  debugEnd?.call('MONERO_Wallet_maximumAllowedAmount');
+  return s;
+}
+
+void Wallet_init3(
+  wallet ptr, {
+  required String argv0,
+  required String defaultLogBaseName,
+  required String logPath,
+  required bool console,
+}) {
+  debugStart?.call('MONERO_Wallet_init3');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final argv0_ = argv0.toNativeUtf8().cast<Char>();
+  final defaultLogBaseName_ = defaultLogBaseName.toNativeUtf8().cast<Char>();
+  final logPath_ = logPath.toNativeUtf8().cast<Char>();
+  final s = lib!
+      .MONERO_Wallet_init3(ptr, argv0_, defaultLogBaseName_, logPath_, console);
+  calloc.free(argv0_);
+  calloc.free(defaultLogBaseName_);
+  calloc.free(logPath_);
+  debugEnd?.call('MONERO_Wallet_init3');
+  return s;
+}
+
+String Wallet_getPolyseed(wallet ptr, {required String passphrase}) {
+  debugStart?.call('MONERO_Wallet_getPolyseed');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final passphrase_ = passphrase.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.MONERO_Wallet_getPolyseed(ptr, passphrase_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(passphrase_);
+    debugEnd?.call('MONERO_Wallet_getPolyseed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getPolyseed', e);
+    debugEnd?.call('MONERO_Wallet_getPolyseed');
+    return "";
+  }
+}
+
+String Wallet_createPolyseed({
+  String language = "English",
+}) {
+  debugStart?.call('MONERO_Wallet_createPolyseed');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final language_ = language.toNativeUtf8();
+    final strPtr =
+        lib!.MONERO_Wallet_createPolyseed(language_.cast()).cast<Utf8>();
+    calloc.free(language_);
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_createPolyseed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_createPolyseed', e);
+    debugEnd?.call('MONERO_Wallet_createPolyseed');
+    return "";
+  }
+}
+
+void Wallet_startRefresh(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_startRefresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final startRefresh = lib!.MONERO_Wallet_startRefresh(ptr);
+  debugEnd?.call('MONERO_Wallet_startRefresh');
+  return startRefresh;
+}
+
+void Wallet_pauseRefresh(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_pauseRefresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final pauseRefresh = lib!.MONERO_Wallet_pauseRefresh(ptr);
+  debugEnd?.call('MONERO_Wallet_pauseRefresh');
+  return pauseRefresh;
+}
+
+bool Wallet_refresh(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_refresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final refresh = lib!.MONERO_Wallet_refresh(ptr);
+  debugEnd?.call('MONERO_Wallet_refresh');
+  return refresh;
+}
+
+void Wallet_refreshAsync(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_refreshAsync');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final refreshAsync = lib!.MONERO_Wallet_refreshAsync(ptr);
+  debugEnd?.call('MONERO_Wallet_refreshAsync');
+  return refreshAsync;
+}
+
+bool Wallet_rescanBlockchain(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_rescanBlockchain');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final rescanBlockchain = lib!.MONERO_Wallet_rescanBlockchain(ptr);
+  debugEnd?.call('MONERO_Wallet_rescanBlockchain');
+  return rescanBlockchain;
+}
+
+void Wallet_rescanBlockchainAsync(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_rescanBlockchainAsync');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final rescanBlockchainAsync = lib!.MONERO_Wallet_rescanBlockchainAsync(ptr);
+  debugEnd?.call('MONERO_Wallet_rescanBlockchainAsync');
+  return rescanBlockchainAsync;
+}
+
+void Wallet_setAutoRefreshInterval(wallet ptr, {required int millis}) {
+  debugStart?.call('MONERO_Wallet_setAutoRefreshInterval');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final setAutoRefreshInterval =
+      lib!.MONERO_Wallet_setAutoRefreshInterval(ptr, millis);
+  debugEnd?.call('MONERO_Wallet_setAutoRefreshInterval');
+  return setAutoRefreshInterval;
+}
+
+int Wallet_autoRefreshInterval(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_autoRefreshInterval');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final autoRefreshInterval = lib!.MONERO_Wallet_autoRefreshInterval(ptr);
+  debugEnd?.call('MONERO_Wallet_autoRefreshInterval');
+  return autoRefreshInterval;
+}
+
+void Wallet_addSubaddress(wallet ptr,
+    {required int accountIndex, String label = ""}) {
+  debugStart?.call('MONERO_Wallet_addSubaddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_addSubaddress(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_Wallet_addSubaddress');
+  return s;
+}
+
+void Wallet_addSubaddressAccount(wallet ptr, {String label = ""}) {
+  debugStart?.call('MONERO_Wallet_addSubaddressAccount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_addSubaddressAccount(ptr, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_Wallet_addSubaddressAccount');
+  return s;
+}
+
+int Wallet_numSubaddressAccounts(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_numSubaddressAccounts');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final numSubaddressAccounts = lib!.MONERO_Wallet_numSubaddressAccounts(ptr);
+  debugEnd?.call('MONERO_Wallet_numSubaddressAccounts');
+  return numSubaddressAccounts;
+}
+
+int Wallet_numSubaddresses(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('MONERO_Wallet_numSubaddresses');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final numSubaddresses = lib!.MONERO_Wallet_numSubaddresses(ptr, accountIndex);
+  debugEnd?.call('MONERO_Wallet_numSubaddresses');
+  return numSubaddresses;
+}
+
+String Wallet_getSubaddressLabel(wallet ptr,
+    {required int accountIndex, required int addressIndex}) {
+  debugStart?.call('MONERO_Wallet_getSubaddressLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_Wallet_getSubaddressLabel(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_getSubaddressLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getSubaddressLabel', e);
+    debugEnd?.call('MONERO_Wallet_getSubaddressLabel');
+    return "";
+  }
+}
+
+void Wallet_setSubaddressLabel(wallet ptr,
+    {required int accountIndex,
+    required int addressIndex,
+    required String label}) {
+  debugStart?.call('MONERO_Wallet_setSubaddressLabel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_setSubaddressLabel(
+      ptr, accountIndex, addressIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('MONERO_Wallet_setSubaddressLabel');
+  return s;
+}
+
+MultisigState Wallet_multisig(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_multisig');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_Wallet_multisig(ptr);
+  debugEnd?.call('MONERO_Wallet_multisig');
+  return s;
+}
+
+String Wallet_getMultisigInfo(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getMultisigInfo');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_Wallet_getMultisigInfo(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_getMultisigInfo');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getMultisigInfo', e);
+    debugEnd?.call('MONERO_Wallet_getMultisigInfo');
+    return "";
+  }
+}
+
+String Wallet_makeMultisig(
+  wallet ptr, {
+  required List<String> info,
+  required int threshold,
+}) {
+  debugStart?.call('MONERO_Wallet_makeMultisig');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final infoStr = info.join(defaultSeparatorStr).toNativeUtf8();
+    final strPtr = lib!
+        .MONERO_Wallet_makeMultisig(
+          ptr,
+          infoStr.cast(),
+          defaultSeparator.cast(),
+          threshold,
+        )
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    calloc.free(infoStr);
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_makeMultisig');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_makeMultisig', e);
+    debugEnd?.call('MONERO_Wallet_makeMultisig');
+    return "";
+  }
+}
+
+String Wallet_exchangeMultisigKeys(
+  wallet ptr, {
+  required List<String> info,
+  required bool force_update_use_with_caution,
+}) {
+  debugStart?.call('MONERO_Wallet_exchangeMultisigKeys');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final infoStr = info.join(defaultSeparatorStr).toNativeUtf8();
+    final strPtr = lib!
+        .MONERO_Wallet_exchangeMultisigKeys(
+          ptr,
+          infoStr.cast(),
+          defaultSeparator.cast(),
+          force_update_use_with_caution,
+        )
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    calloc.free(infoStr);
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_exchangeMultisigKeys');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_exchangeMultisigKeys', e);
+    debugEnd?.call('MONERO_Wallet_exchangeMultisigKeys');
+    return "";
+  }
+}
+
+List<String> Wallet_exportMultisigImages(
+  wallet ptr, {
+  required List<String> info,
+  required bool force_update_use_with_caution,
+}) {
+  debugStart?.call('MONERO_Wallet_exportMultisigImages');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final infoStr = info.join(defaultSeparatorStr).toNativeUtf8();
+    final strPtr = lib!
+        .MONERO_Wallet_exportMultisigImages(
+          ptr,
+          defaultSeparator.cast(),
+        )
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    calloc.free(infoStr);
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_exportMultisigImages');
+    return str.split(defaultSeparatorStr);
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_exportMultisigImages', e);
+    debugEnd?.call('MONERO_Wallet_exportMultisigImages');
+    return [];
+  }
+}
+
+int Wallet_importMultisigImages(
+  wallet ptr, {
+  required List<String> info,
+}) {
+  debugStart?.call('MONERO_Wallet_importMultisigImages');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final infoStr = info.join(defaultSeparatorStr).toNativeUtf8();
+  final ret = lib!.MONERO_Wallet_importMultisigImages(
+    ptr,
+    infoStr.cast(),
+    defaultSeparator.cast(),
+  );
+  calloc.free(infoStr);
+  debugEnd?.call('MONERO_Wallet_importMultisigImages');
+  return ret;
+}
+
+int Wallet_hasMultisigPartialKeyImages(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_hasMultisigPartialKeyImages');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_hasMultisigPartialKeyImages(
+    ptr,
+  );
+  debugEnd?.call('MONERO_Wallet_hasMultisigPartialKeyImages');
+  return ret;
+}
+
+PendingTransaction Wallet_restoreMultisigTransaction(
+  wallet ptr, {
+  required String signData,
+}) {
+  debugStart?.call('MONERO_Wallet_restoreMultisigTransaction');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final signData_ = signData.toNativeUtf8();
+  final ret = lib!.MONERO_Wallet_restoreMultisigTransaction(
+    ptr,
+    signData_.cast(),
+  );
+  calloc.free(signData_);
+  debugEnd?.call('MONERO_Wallet_restoreMultisigTransaction');
+  return ret;
+}
+
+PendingTransaction Wallet_createTransactionMultDest(
+  wallet wptr, {
+  required List<String> dstAddr,
+  String paymentId = "",
+  required bool isSweepAll,
+  required List<int> amounts,
+  required int mixinCount,
+  required int pendingTransactionPriority,
+  required int subaddr_account,
+  List<String> preferredInputs = const [],
+}) {
+  debugStart?.call('MONERO_Wallet_createTransactionMultDest');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final dst_addr_list = dstAddr.join(defaultSeparatorStr).toNativeUtf8();
+  final payment_id = paymentId.toNativeUtf8();
+  final amount_list =
+      amounts.map((e) => e.toString()).join(defaultSeparatorStr).toNativeUtf8();
+  final preferredInputs_ =
+      preferredInputs.join(defaultSeparatorStr).toNativeUtf8();
+  final ret = lib!.MONERO_Wallet_createTransactionMultDest(
+    wptr,
+    dst_addr_list.cast(),
+    defaultSeparator,
+    payment_id.cast(),
+    isSweepAll,
+    amount_list.cast(),
+    defaultSeparator,
+    mixinCount,
+    pendingTransactionPriority,
+    subaddr_account,
+    preferredInputs_.cast(),
+    defaultSeparator,
+  );
+  calloc.free(dst_addr_list);
+  calloc.free(payment_id);
+  calloc.free(amount_list);
+  calloc.free(preferredInputs_);
+  debugEnd?.call('MONERO_Wallet_createTransactionMultDest');
+  return ret;
+}
+
+PendingTransaction Wallet_createTransaction(wallet ptr,
+    {required String dst_addr,
+    required String payment_id,
+    required int amount,
+    required int mixin_count,
+    required int pendingTransactionPriority,
+    required int subaddr_account,
+    List<String> preferredInputs = const []}) {
+  debugStart?.call('MONERO_Wallet_createTransaction');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final dst_addr_ = dst_addr.toNativeUtf8().cast<Char>();
+  final payment_id_ = payment_id.toNativeUtf8().cast<Char>();
+  final preferredInputs_ =
+      preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_createTransaction(
+    ptr,
+    dst_addr_,
+    payment_id_,
+    amount,
+    mixin_count,
+    pendingTransactionPriority,
+    subaddr_account,
+    preferredInputs_,
+    defaultSeparator,
+  );
+  calloc.free(dst_addr_);
+  calloc.free(payment_id_);
+  calloc.free(preferredInputs_);
+  debugEnd?.call('MONERO_Wallet_createTransaction');
+  return s;
+}
+
+UnsignedTransaction Wallet_loadUnsignedTx(wallet ptr,
+    {required String unsigned_filename}) {
+  debugStart?.call('MONERO_Wallet_loadUnsignedTx');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final unsigned_filename_ = unsigned_filename.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_loadUnsignedTx(ptr, unsigned_filename_);
+  calloc.free(unsigned_filename_);
+  debugEnd?.call('MONERO_Wallet_loadUnsignedTx');
+  return s;
+}
+
+UnsignedTransaction Wallet_loadUnsignedTxUR(wallet ptr,
+    {required String input}) {
+  debugStart?.call('MONERO_Wallet_loadUnsignedTxUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final input_ = input.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_loadUnsignedTxUR(ptr, input_);
+  calloc.free(input_);
+  debugEnd?.call('MONERO_Wallet_loadUnsignedTxUR');
+  return s;
+}
+
+bool Wallet_submitTransaction(wallet ptr, String filename) {
+  debugStart?.call('MONERO_Wallet_submitTransaction');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_submitTransaction(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('MONERO_Wallet_submitTransaction');
+  return s;
+}
+
+bool Wallet_submitTransactionUR(wallet ptr, String input) {
+  debugStart?.call('MONERO_Wallet_submitTransactionUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final input_ = input.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_submitTransactionUR(ptr, input_);
+  calloc.free(input_);
+  debugEnd?.call('MONERO_Wallet_submitTransactionUR');
+  return s;
+}
+
+bool Wallet_hasUnknownKeyImages(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_hasUnknownKeyImages');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_Wallet_hasUnknownKeyImages(ptr);
+  debugEnd?.call('MONERO_Wallet_hasUnknownKeyImages');
+  return s;
+}
+
+bool Wallet_exportKeyImages(wallet ptr, String filename, {required bool all}) {
+  debugStart?.call('MONERO_Wallet_exportKeyImages');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_exportKeyImages(ptr, filename_, all);
+  calloc.free(filename_);
+  debugEnd?.call('MONERO_Wallet_exportKeyImages');
+  return s;
+}
+
+String Wallet_exportKeyImagesUR(
+  wallet ptr, {
+  int max_fragment_length = 130,
+  bool all = false,
+}) {
+  debugStart?.call('MONERO_Wallet_exportKeyImagesUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_Wallet_exportKeyImagesUR(ptr, max_fragment_length, all)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_exportKeyImagesUR');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_exportKeyImagesUR', e);
+    debugEnd?.call('MONERO_Wallet_exportKeyImagesUR');
+    return "";
+  }
+}
+
+bool Wallet_importKeyImages(wallet ptr, String filename) {
+  debugStart?.call('MONERO_Wallet_importKeyImages');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_importKeyImages(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('MONERO_Wallet_importKeyImages');
+  return s;
+}
+
+bool Wallet_importKeyImagesUR(wallet ptr, String input) {
+  debugStart?.call('MONERO_Wallet_importKeyImagesUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final input_ = input.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_importKeyImagesUR(ptr, input_);
+  calloc.free(input_);
+  debugEnd?.call('MONERO_Wallet_importKeyImagesUR');
+  return s;
+}
+
+bool Wallet_exportOutputs(wallet ptr, String filename, {required bool all}) {
+  debugStart?.call('MONERO_Wallet_exportOutputs');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_exportOutputs(ptr, filename_, all);
+  calloc.free(filename_);
+  debugEnd?.call('MONERO_Wallet_exportOutputs');
+  return s;
+}
+
+String Wallet_exportOutputsUR(
+  wallet ptr, {
+  int max_fragment_length = 130,
+  bool all = false,
+}) {
+  debugStart?.call('MONERO_Wallet_exportOutputsUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_Wallet_exportOutputsUR(ptr, max_fragment_length, all)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_exportOutputsUR');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_exportOutputsUR', e);
+    debugEnd?.call('MONERO_Wallet_exportOutputsUR');
+    return "";
+  }
+}
+
+bool Wallet_importOutputs(wallet ptr, String filename) {
+  debugStart?.call('MONERO_Wallet_importOutputs');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_importOutputs(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('MONERO_Wallet_importOutputs');
+  return s;
+}
+
+bool Wallet_importOutputsUR(wallet ptr, String input) {
+  debugStart?.call('MONERO_Wallet_importOutputsUR');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final input_ = input.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_importOutputsUR(ptr, input_);
+  calloc.free(input_);
+  debugEnd?.call('MONERO_Wallet_importOutputsUR');
+  return s;
+}
+
+bool Wallet_setupBackgroundSync(
+  wallet ptr, {
+  required int backgroundSyncType,
+  required String walletPassword,
+  required String backgroundCachePassword,
+}) {
+  debugStart?.call('MONERO_Wallet_setupBackgroundSync');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final walletPassword_ = walletPassword.toNativeUtf8().cast<Char>();
+  final backgroundCachePassword_ =
+      backgroundCachePassword.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_Wallet_setupBackgroundSync(
+      ptr, backgroundSyncType, walletPassword_, backgroundCachePassword_);
+  calloc.free(walletPassword_);
+  calloc.free(backgroundCachePassword_);
+  debugEnd?.call('MONERO_Wallet_setupBackgroundSync');
+  return s;
+}
+
+int Wallet_getBackgroundSyncType(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getBackgroundSyncType');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_getBackgroundSyncType(ptr);
+  debugEnd?.call('MONERO_Wallet_getBackgroundSyncType');
+  return v;
+}
+
+bool Wallet_startBackgroundSync(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_startBackgroundSync');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_startBackgroundSync(ptr);
+  debugEnd?.call('MONERO_Wallet_startBackgroundSync');
+  return v;
+}
+
+bool Wallet_stopBackgroundSync(wallet ptr, String walletPassword) {
+  debugStart?.call('MONERO_Wallet_stopBackgroundSync');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final walletPassword_ = walletPassword.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_Wallet_stopBackgroundSync(ptr, walletPassword_);
+  calloc.free(walletPassword_);
+  debugEnd?.call('MONERO_Wallet_stopBackgroundSync');
+  return v;
+}
+
+bool Wallet_isBackgroundSyncing(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_isBackgroundSyncing');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_isBackgroundSyncing(ptr);
+  debugEnd?.call('MONERO_Wallet_isBackgroundSyncing');
+  return v;
+}
+
+bool Wallet_isBackgroundWallet(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_isBackgroundWallet');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_isBackgroundWallet(ptr);
+  debugEnd?.call('MONERO_Wallet_isBackgroundWallet');
+  return v;
+}
+
+TransactionHistory Wallet_history(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_history');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final history = lib!.MONERO_Wallet_history(ptr);
+  debugEnd?.call('MONERO_Wallet_history');
+  return history;
+}
+
+AddressBook Wallet_addressBook(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_addressBook');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final history = lib!.MONERO_Wallet_addressBook(ptr);
+  debugEnd?.call('MONERO_Wallet_addressBook');
+  return history;
+}
+
+AddressBook Wallet_coins(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_coins');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final history = lib!.MONERO_Wallet_coins(ptr);
+  debugEnd?.call('MONERO_Wallet_coins');
+  return history;
+}
+
+AddressBook Wallet_subaddress(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_subaddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final history = lib!.MONERO_Wallet_subaddress(ptr);
+  debugEnd?.call('MONERO_Wallet_subaddress');
+  return history;
+}
+
+AddressBook Wallet_subaddressAccount(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_subaddressAccount');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final history = lib!.MONERO_Wallet_subaddressAccount(ptr);
+  debugEnd?.call('MONERO_Wallet_subaddressAccount');
+  return history;
+}
+
+int Wallet_defaultMixin(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_defaultMixin');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_defaultMixin(ptr);
+  debugEnd?.call('MONERO_Wallet_defaultMixin');
+  return v;
+}
+
+void Wallet_setDefaultMixin(wallet ptr, int arg) {
+  debugStart?.call('MONERO_Wallet_setDefaultMixin');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_setDefaultMixin(ptr, arg);
+  debugEnd?.call('MONERO_Wallet_setDefaultMixin');
+  return v;
+}
+
+bool Wallet_setCacheAttribute(wallet ptr,
+    {required String key, required String value}) {
+  debugStart?.call('MONERO_Wallet_setCacheAttribute');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final key_ = key.toNativeUtf8().cast<Char>();
+  final value_ = value.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_Wallet_setCacheAttribute(ptr, key_, value_);
+  calloc.free(key_);
+  calloc.free(value_);
+  debugEnd?.call('MONERO_Wallet_setCacheAttribute');
+  return v;
+}
+
+String Wallet_getCacheAttribute(wallet ptr, {required String key}) {
+  debugStart?.call('MONERO_Wallet_getCacheAttribute');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final key_ = key.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.MONERO_Wallet_getCacheAttribute(ptr, key_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(key_);
+    debugEnd?.call('MONERO_Wallet_getCacheAttribute');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getCacheAttribute', e);
+    debugEnd?.call('MONERO_Wallet_getCacheAttribute');
+    return "";
+  }
+}
+
+bool Wallet_setUserNote(wallet ptr,
+    {required String txid, required String note}) {
+  debugStart?.call('MONERO_Wallet_setUserNote');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final note_ = note.toNativeUtf8().cast<Char>();
+  final v = lib!.MONERO_Wallet_setUserNote(ptr, txid_, note_);
+  calloc.free(txid_);
+  calloc.free(note_);
+  debugEnd?.call('MONERO_Wallet_setUserNote');
+  return v;
+}
+
+String Wallet_getUserNote(wallet ptr, {required String txid}) {
+  debugStart?.call('MONERO_Wallet_getUserNote');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final txid_ = txid.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.MONERO_Wallet_getUserNote(ptr, txid_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(txid_);
+    debugEnd?.call('MONERO_Wallet_getUserNote');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getUserNote', e);
+    debugEnd?.call('MONERO_Wallet_getUserNote');
+    return "";
+  }
+}
+
+String Wallet_getTxKey(wallet ptr, {required String txid}) {
+  debugStart?.call('MONERO_Wallet_getTxKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final txid_ = txid.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.MONERO_Wallet_getTxKey(ptr, txid_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(txid_);
+    debugEnd?.call('MONERO_Wallet_getTxKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_getTxKey', e);
+    debugEnd?.call('MONERO_Wallet_getTxKey');
+    return "";
+  }
+}
+
+String Wallet_signMessage(
+  wallet ptr, {
+  required String message,
+  required String address,
+}) {
+  debugStart?.call('MONERO_Wallet_signMessage');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final message_ = message.toNativeUtf8().cast<Char>();
+    final address_ = address.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.MONERO_Wallet_signMessage(ptr, message_, address_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    calloc.free(message_);
+    calloc.free(address_);
+    debugEnd?.call('MONERO_Wallet_signMessage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_signMessage', e);
+    debugEnd?.call('MONERO_Wallet_signMessage');
+    return "";
+  }
+}
+
+bool Wallet_verifySignedMessage(
+  wallet ptr, {
+  required String message,
+  required String address,
+  required String signature,
+}) {
+  debugStart?.call('MONERO_Wallet_verifySignedMessage');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final message_ = message.toNativeUtf8().cast<Char>();
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final signature_ = signature.toNativeUtf8().cast<Char>();
+  final v = lib!
+      .MONERO_Wallet_verifySignedMessage(ptr, message_, address_, signature_);
+  calloc.free(message_);
+  calloc.free(address_);
+  calloc.free(signature_);
+  debugEnd?.call('MONERO_Wallet_verifySignedMessage');
+  return v;
+}
+
+bool Wallet_rescanSpent(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_rescanSpent');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_rescanSpent(ptr);
+  debugEnd?.call('MONERO_Wallet_rescanSpent');
+  return v;
+}
+
+void Wallet_setOffline(wallet ptr, {required bool offline}) {
+  debugStart?.call('MONERO_Wallet_setOffline');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final setOffline = lib!.MONERO_Wallet_setOffline(ptr, offline);
+  debugEnd?.call('MONERO_Wallet_setOffline');
+  return setOffline;
+}
+
+bool Wallet_isOffline(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_isOffline');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final isOffline = lib!.MONERO_Wallet_isOffline(ptr);
+  debugEnd?.call('MONERO_Wallet_isOffline');
+  return isOffline;
+}
+
+void Wallet_segregatePreForkOutputs(wallet ptr, {required bool segregate}) {
+  debugStart?.call('MONERO_Wallet_segregatePreForkOutputs');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_segregatePreForkOutputs(ptr, segregate);
+  debugEnd?.call('MONERO_Wallet_segregatePreForkOutputs');
+  return v;
+}
+
+void Wallet_segregationHeight(wallet ptr, {required int height}) {
+  debugStart?.call('MONERO_Wallet_segregationHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_segregationHeight(ptr, height);
+  debugEnd?.call('MONERO_Wallet_segregationHeight');
+  return v;
+}
+
+void Wallet_keyReuseMitigation2(wallet ptr, {required bool mitigation}) {
+  debugStart?.call('MONERO_Wallet_keyReuseMitigation2');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_keyReuseMitigation2(ptr, mitigation);
+  debugEnd?.call('MONERO_Wallet_keyReuseMitigation2');
+  return v;
+}
+
+bool Wallet_lockKeysFile(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_lockKeysFile');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_lockKeysFile(ptr);
+  debugEnd?.call('MONERO_Wallet_lockKeysFile');
+  return v;
+}
+
+bool Wallet_unlockKeysFile(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_unlockKeysFile');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_unlockKeysFile(ptr);
+  debugEnd?.call('MONERO_Wallet_unlockKeysFile');
+  return v;
+}
+
+bool Wallet_isKeysFileLocked(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_isKeysFileLocked');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_isKeysFileLocked(ptr);
+  debugEnd?.call('MONERO_Wallet_isKeysFileLocked');
+  return v;
+}
+
+int Wallet_getDeviceType(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getDeviceType');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_getDeviceType(ptr);
+  debugEnd?.call('MONERO_Wallet_getDeviceType');
+  return v;
+}
+
+int Wallet_coldKeyImageSync(wallet ptr,
+    {required int spent, required int unspent}) {
+  debugStart?.call('MONERO_Wallet_coldKeyImageSync');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final v = lib!.MONERO_Wallet_coldKeyImageSync(ptr, spent, unspent);
+  debugEnd?.call('MONERO_Wallet_coldKeyImageSync');
+  return v;
+}
+
+String Wallet_deviceShowAddress(wallet ptr,
+    {required int accountIndex, required int addressIndex}) {
+  debugStart?.call('MONERO_Wallet_deviceShowAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .MONERO_Wallet_deviceShowAddress(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_Wallet_deviceShowAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_Wallet_deviceShowAddress', e);
+    debugEnd?.call('MONERO_Wallet_deviceShowAddress');
+    return "";
+  }
+}
+
+bool Wallet_reconnectDevice(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_reconnectDevice');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_reconnectDevice(ptr);
+  debugEnd?.call('MONERO_Wallet_reconnectDevice');
+  return ret;
+}
+
+int Wallet_getBytesReceived(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getBytesReceived');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final getBytesReceived = lib!.MONERO_Wallet_getBytesReceived(ptr);
+  debugEnd?.call('MONERO_Wallet_getBytesReceived');
+  return getBytesReceived;
+}
+
+int MONERO_Wallet_getBytesSent(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getBytesSent');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final getBytesSent = lib!.MONERO_Wallet_getBytesSent(ptr);
+  debugEnd?.call('MONERO_Wallet_getBytesSent');
+  return getBytesSent;
+}
+
+bool Wallet_getStateIsConnected(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getStateIsConnected');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getStateIsConnected(ptr);
+  debugEnd?.call('MONERO_Wallet_getStateIsConnected');
+  return ret;
+}
+
+Pointer<UnsignedChar> Wallet_getSendToDevice(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getSendToDevice');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getSendToDevice(ptr);
+  debugEnd?.call('MONERO_Wallet_getSendToDevice');
+  return ret;
+}
+
+int Wallet_getSendToDeviceLength(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getSendToDeviceLength');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getSendToDeviceLength(ptr);
+  debugEnd?.call('MONERO_Wallet_getSendToDeviceLength');
+  return ret;
+}
+
+Pointer<UnsignedChar> Wallet_getReceivedFromDevice(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getReceivedFromDevice');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getReceivedFromDevice(ptr);
+  debugEnd?.call('MONERO_Wallet_getReceivedFromDevice');
+  return ret;
+}
+
+int Wallet_getReceivedFromDeviceLength(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getReceivedFromDeviceLength');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getReceivedFromDeviceLength(ptr);
+  debugEnd?.call('MONERO_Wallet_getReceivedFromDeviceLength');
+  return ret;
+}
+
+bool Wallet_getWaitsForDeviceSend(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getWaitsForDeviceSend');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getWaitsForDeviceSend(ptr);
+  debugEnd?.call('MONERO_Wallet_getWaitsForDeviceSend');
+  return ret;
+}
+
+bool Wallet_getWaitsForDeviceReceive(wallet ptr) {
+  debugStart?.call('MONERO_Wallet_getWaitsForDeviceReceive');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_getWaitsForDeviceReceive(ptr);
+  debugEnd?.call('MONERO_Wallet_getWaitsForDeviceReceive');
+  return ret;
+}
+
+void Wallet_setDeviceReceivedData(
+    wallet ptr, Pointer<UnsignedChar> data, int len) {
+  debugStart?.call('MONERO_Wallet_setDeviceReceivedData');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_setDeviceReceivedData(ptr, data, len);
+  debugEnd?.call('MONERO_Wallet_setDeviceReceivedData');
+  return ret;
+}
+
+void Wallet_setDeviceSendData(wallet ptr, Pointer<UnsignedChar> data, int len) {
+  debugStart?.call('MONERO_Wallet_setDeviceSendData');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.MONERO_Wallet_setDeviceSendData(ptr, data, len);
+  debugEnd?.call('MONERO_Wallet_setDeviceSendData');
+  return ret;
+}
+
+// WalletManager
+
+typedef WalletManager = Pointer<Void>;
+
+wallet WalletManager_createWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  String language = "English",
+  int networkType = 0,
+}) {
+  debugStart?.call('MONERO_WalletManager_createWallet');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final w = lib!.MONERO_WalletManager_createWallet(
+      wm_ptr, path_, password_, language_, networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('MONERO_WalletManager_createWallet');
+  return w;
+}
+
+wallet WalletManager_openWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+}) {
+  debugStart?.call('MONERO_WalletManager_openWallet');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final w = lib!
+      .MONERO_WalletManager_openWallet(wm_ptr, path_, password_, networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  debugEnd?.call('MONERO_WalletManager_openWallet');
+  return w;
+}
+
+wallet WalletManager_recoveryWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  required String mnemonic,
+  int networkType = 0,
+  required int restoreHeight,
+  int kdfRounds = 0,
+  required String seedOffset,
+}) {
+  debugStart?.call('MONERO_WalletManager_recoveryWallet');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final mnemonic_ = mnemonic.toNativeUtf8().cast<Char>();
+  final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+  final w = lib!.MONERO_WalletManager_recoveryWallet(wm_ptr, path_, password_,
+      mnemonic_, networkType, restoreHeight, kdfRounds, seedOffset_);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(mnemonic_);
+  calloc.free(seedOffset_);
+  debugEnd?.call('MONERO_WalletManager_recoveryWallet');
+  return w;
+}
+
+wallet WalletManager_createWalletFromKeys(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  String language = "English",
+  int nettype = 1,
+  required int restoreHeight,
+  required String addressString,
+  required String viewKeyString,
+  required String spendKeyString,
+  int kdf_rounds = 1,
+}) {
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  debugStart?.call('MONERO_WalletManager_createWalletFromKeys');
+
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final addressString_ = addressString.toNativeUtf8().cast<Char>();
+  final viewKeyString_ = viewKeyString.toNativeUtf8().cast<Char>();
+  final spendKeyString_ = spendKeyString.toNativeUtf8().cast<Char>();
+
+  final w = lib!.MONERO_WalletManager_createWalletFromKeys(
+    wm_ptr,
+    path_,
+    password_,
+    language_,
+    nettype,
+    restoreHeight,
+    addressString_,
+    viewKeyString_,
+    spendKeyString_,
+    kdf_rounds,
+  );
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  calloc.free(addressString_);
+  calloc.free(viewKeyString_);
+  calloc.free(spendKeyString_);
+  debugEnd?.call('MONERO_WalletManager_createWalletFromKeys');
+  return w;
+}
+
+wallet WalletManager_createDeterministicWalletFromSpendKey(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String language,
+  required String spendKeyString,
+  required bool newWallet,
+  required int restoreHeight,
+  int kdfRounds = 1,
+}) {
+  debugStart
+      ?.call('MONERO_WalletManager_createDeterministicWalletFromSpendKey');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final spendKeyString_ = spendKeyString.toNativeUtf8().cast<Char>();
+  final w = lib!.MONERO_WalletManager_createDeterministicWalletFromSpendKey(
+      wm_ptr,
+      path_,
+      password_,
+      language_,
+      networkType,
+      restoreHeight,
+      spendKeyString_,
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  calloc.free(spendKeyString_);
+  debugEnd?.call('MONERO_WalletManager_createDeterministicWalletFromSpendKey');
+  return w;
+}
+
+wallet WalletManager_createWalletFromDevice(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String deviceName,
+  int restoreHeight = 0,
+  String subaddressLookahead = "",
+  int kdfRounds = 1,
+}) {
+  debugStart?.call('MONERO_WalletManager_createWalletFromDevice');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final deviceName_ = deviceName.toNativeUtf8().cast<Char>();
+  final subaddressLookahead_ = subaddressLookahead.toNativeUtf8().cast<Char>();
+  final w = lib!.MONERO_WalletManager_createWalletFromDevice(
+      wm_ptr,
+      path_,
+      password_,
+      networkType,
+      deviceName_,
+      restoreHeight,
+      subaddressLookahead_,
+      defaultSeparator, // ignore
+      defaultSeparator, // ignore
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(deviceName_);
+  calloc.free(subaddressLookahead_);
+  debugEnd?.call('MONERO_WalletManager_createWalletFromDevice');
+  return w;
+}
+
+wallet WalletManager_createWalletFromPolyseed(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String mnemonic,
+  required String seedOffset,
+  required bool newWallet,
+  required int restoreHeight,
+  required int kdfRounds,
+}) {
+  debugStart?.call('MONERO_WalletManager_createWalletFromPolyseed');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final mnemonic_ = mnemonic.toNativeUtf8().cast<Char>();
+  final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+  final w = lib!.MONERO_WalletManager_createWalletFromPolyseed(
+      wm_ptr,
+      path_,
+      password_,
+      networkType,
+      mnemonic_,
+      seedOffset_,
+      newWallet,
+      restoreHeight,
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(mnemonic_);
+  calloc.free(seedOffset_);
+  debugEnd?.call('MONERO_WalletManager_createWalletFromPolyseed');
+  return w;
+}
+
+bool WalletManager_closeWallet(WalletManager wm_ptr, wallet ptr, bool store) {
+  debugStart?.call('MONERO_WalletManager_closeWallet');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final closeWallet = lib!.MONERO_WalletManager_closeWallet(wm_ptr, ptr, store);
+  debugEnd?.call('MONERO_WalletManager_closeWallet');
+  return closeWallet;
+}
+
+bool WalletManager_walletExists(WalletManager wm_ptr, String path) {
+  debugStart?.call('MONERO_WalletManager_walletExists');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManager_walletExists(wm_ptr, path_);
+  calloc.free(path_);
+  debugEnd?.call('MONERO_WalletManager_walletExists');
+  return s;
+}
+
+bool WalletManager_verifyWalletPassword(
+  WalletManager wm_ptr, {
+  required String keysFileName,
+  required String password,
+  required bool noSpendKey,
+  required int kdfRounds,
+}) {
+  debugStart?.call('MONERO_WalletManager_verifyWalletPassword');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final keysFileName_ = keysFileName.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManager_verifyWalletPassword(
+      wm_ptr, keysFileName_, password_, noSpendKey, kdfRounds);
+  calloc.free(keysFileName_);
+  calloc.free(password_);
+  debugEnd?.call('MONERO_WalletManager_verifyWalletPassword');
+  return s;
+}
+
+String WalletManager_findWallets(WalletManager wm_ptr, {required String path}) {
+  debugStart?.call('MONERO_WalletManager_findWallets');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final path_ = path.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .MONERO_WalletManager_findWallets(wm_ptr, path_, defaultSeparator)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    calloc.free(path_);
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_WalletManager_findWallets');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_WalletManager_findWallets', e);
+    debugEnd?.call('MONERO_WalletManager_findWallets');
+    return "";
+  }
+}
+
+String WalletManager_errorString(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_errorString');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.MONERO_WalletManager_errorString(wm_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_WalletManager_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_WalletManager_errorString', e);
+    debugEnd?.call('MONERO_WalletManager_errorString');
+    return "";
+  }
+}
+
+void WalletManager_setDaemonAddress(WalletManager wm_ptr, String address) {
+  debugStart?.call('MONERO_WalletManager_setDaemonAddress');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManager_setDaemonAddress(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('MONERO_WalletManager_setDaemonAddress');
+  return s;
+}
+
+int WalletManager_blockchainHeight(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_blockchainHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManager_blockchainHeight(wm_ptr);
+  debugEnd?.call('MONERO_WalletManager_blockchainHeight');
+  return s;
+}
+
+int WalletManager_blockchainTargetHeight(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_blockchainTargetHeight');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManager_blockchainTargetHeight(wm_ptr);
+  debugEnd?.call('MONERO_WalletManager_blockchainTargetHeight');
+  return s;
+}
+
+int WalletManager_networkDifficulty(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_networkDifficulty');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManager_networkDifficulty(wm_ptr);
+  debugEnd?.call('MONERO_WalletManager_networkDifficulty');
+  return s;
+}
+
+double WalletManager_miningHashRate(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_miningHashRate');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManager_miningHashRate(wm_ptr);
+  debugEnd?.call('MONERO_WalletManager_miningHashRate');
+  return s;
+}
+
+int WalletManager_blockTarget(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_blockTarget');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManager_blockTarget(wm_ptr);
+  debugEnd?.call('MONERO_WalletManager_blockTarget');
+  return s;
+}
+
+bool WalletManager_isMining(WalletManager wm_ptr) {
+  debugStart?.call('MONERO_WalletManager_isMining');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManager_isMining(wm_ptr);
+  debugEnd?.call('MONERO_WalletManager_isMining');
+  return s;
+}
+
+bool WalletManager_startMining(
+  WalletManager wm_ptr, {
+  required String address,
+  required int threads,
+  required bool backgroundMining,
+  required bool ignoreBattery,
+}) {
+  debugStart?.call('MONERO_WalletManager_startMining');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManager_startMining(
+      wm_ptr, address_, threads, backgroundMining, ignoreBattery);
+  calloc.free(address_);
+  debugEnd?.call('MONERO_WalletManager_startMining');
+  return s;
+}
+
+bool WalletManager_stopMining(WalletManager wm_ptr, String address) {
+  debugStart?.call('MONERO_WalletManager_stopMining');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManager_stopMining(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('MONERO_WalletManager_stopMining');
+  return s;
+}
+
+String WalletManager_resolveOpenAlias(
+  WalletManager wm_ptr, {
+  required String address,
+  required bool dnssecValid,
+}) {
+  debugStart?.call('MONERO_WalletManager_resolveOpenAlias');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  try {
+    final address_ = address.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .MONERO_WalletManager_resolveOpenAlias(wm_ptr, address_, dnssecValid)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    MONERO_free(strPtr.cast());
+    debugEnd?.call('MONERO_WalletManager_resolveOpenAlias');
+    calloc.free(address_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('MONERO_WalletManager_resolveOpenAlias', e);
+    debugEnd?.call('MONERO_WalletManager_resolveOpenAlias');
+    return "";
+  }
+}
+
+bool WalletManager_setProxy(WalletManager wm_ptr, String address) {
+  debugStart?.call('MONERO_WalletManager_setProxy');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManager_setProxy(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('MONERO_WalletManager_setProxy');
+  return s;
+}
+
+void WalletManagerFactory_setLogLevel(int level) {
+  debugStart?.call('MONERO_WalletManagerFactory_setLogLevel');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManagerFactory_setLogLevel(level);
+  debugEnd?.call('MONERO_WalletManagerFactory_setLogLevel');
+  return s;
+}
+
+void WalletManagerFactory_setLogCategories(String categories) {
+  debugStart?.call('MONERO_WalletManagerFactory_setLogCategories');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final categories_ = categories.toNativeUtf8().cast<Char>();
+  final s = lib!.MONERO_WalletManagerFactory_setLogCategories(categories_);
+  calloc.free(categories_);
+  debugEnd?.call('MONERO_WalletManagerFactory_setLogCategories');
+  return s;
+}
+
+WalletManager WalletManagerFactory_getWalletManager() {
+  debugStart?.call('MONERO_WalletManagerFactory_getWalletManager');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  final s = lib!.MONERO_WalletManagerFactory_getWalletManager();
+  debugEnd?.call('MONERO_WalletManagerFactory_getWalletManager');
+  return s;
+}
+
+// class LogLevel {
+//   int get LogLevel_Silent => lib!.LogLevel_Silent;
+//   int get LogLevel_0 => lib!.LogLevel_0;
+//   int get LogLevel_1 => lib!.LogLevel_1;
+//   int get LogLevel_2 => lib!.LogLevel_2;
+//   int get LogLevel_3 => lib!.LogLevel_3;
+//   int get LogLevel_4 => lib!.LogLevel_4;
+//   int get LogLevel_Min => LogLevel_Silent;
+//   int get LogLevel_Max => lib!.LogLevel_4;
+// }
+
+// class ConnectionStatus {
+//   int get Disconnected => lib!.WalletConnectionStatus_Disconnected;
+//   int get Connected => lib!.WalletConnectionStatus_Connected;
+//   int get WrongVersion => lib!.WalletConnectionStatus_WrongVersion;
+// }
+
+// DEBUG
+
+class libOk {
+  libOk(
+    this.test1,
+    this.test2,
+    this.test3,
+    this.test4,
+    this.test5,
+    this.test5_std,
+  );
+  final bool test1;
+  final int test2;
+  final int test3;
+  final Pointer<Void> test4;
+  final Pointer<Char> test5;
+  String get test5_str {
+    try {
+      return test5.cast<Utf8>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  String get test5_str16 {
+    try {
+      return test5.cast<Utf16>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  final Pointer<Char> test5_std;
+  String get test5_std_str {
+    try {
+      return test5_std.cast<Utf8>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  String get test5_std_str16 {
+    try {
+      return test5_std.cast<Utf16>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      "test1": test1,
+      "test2": test2,
+      "test3": test3,
+      "test4": test4.toString(),
+      "test5": test5.toString(),
+      "test5_str": test5_str,
+      "test5_std": test5_std.toString(),
+      "test5_std_str": test5_std_str,
+    };
+  }
+}
+
+libOk isLibOk() {
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+  lib!.MONERO_DEBUG_test0();
+  final test1 = lib!.MONERO_DEBUG_test1(true);
+  final test2 = lib!.MONERO_DEBUG_test2(-1);
+  final test3 = lib!.MONERO_DEBUG_test3(1);
+  final test4 = lib!.MONERO_DEBUG_test4(1);
+  final test5 = lib!.MONERO_DEBUG_test5();
+  final test5_std = lib!.MONERO_DEBUG_test5_std();
+  return libOk(test1, test2, test3, test4, test5, test5_std);
+}
+
+// cake world
+
+typedef WalletListener = Pointer<Void>;
+
+WalletListener MONERO_cw_getWalletListener(wallet wptr) {
+  debugStart?.call('MONERO_cw_getWalletListener');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_cw_getWalletListener(wptr);
+  debugEnd?.call('MONERO_cw_getWalletListener');
+  return s;
+}
+
+void MONERO_cw_WalletListener_resetNeedToRefresh(WalletListener wlptr) {
+  debugStart?.call('MONERO_cw_WalletListener_resetNeedToRefresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_cw_WalletListener_resetNeedToRefresh(wlptr);
+  debugEnd?.call('MONERO_cw_WalletListener_resetNeedToRefresh');
+  return s;
+}
+
+bool MONERO_cw_WalletListener_isNeedToRefresh(WalletListener wlptr) {
+  debugStart?.call('MONERO_cw_WalletListener_isNeedToRefresh');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_cw_WalletListener_isNeedToRefresh(wlptr);
+  debugEnd?.call('MONERO_cw_WalletListener_isNeedToRefresh');
+  return s;
+}
+
+bool MONERO_cw_WalletListener_isNewTransactionExist(WalletListener wlptr) {
+  debugStart?.call('MONERO_cw_WalletListener_isNewTransactionExist');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_cw_WalletListener_isNewTransactionExist(wlptr);
+  debugEnd?.call('MONERO_cw_WalletListener_isNewTransactionExist');
+  return s;
+}
+
+void MONERO_cw_WalletListener_resetIsNewTransactionExist(WalletListener wlptr) {
+  debugStart?.call('MONERO_cw_WalletListener_resetIsNewTransactionExist');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_cw_WalletListener_resetIsNewTransactionExist(wlptr);
+  debugEnd?.call('MONERO_cw_WalletListener_resetIsNewTransactionExist');
+  return s;
+}
+
+int MONERO_cw_WalletListener_height(WalletListener wlptr) {
+  debugStart?.call('MONERO_cw_WalletListener_height');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_cw_WalletListener_height(wlptr);
+  debugEnd?.call('MONERO_cw_WalletListener_height');
+  return s;
+}
+
+void MONERO_free(Pointer<Void> wlptr) {
+  debugStart?.call('MONERO_free');
+  lib ??= MoneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.MONERO_free(wlptr);
+  debugEnd?.call('MONERO_free');
+  return s;
+}
diff --git a/impls/monero.dart/lib/src/generated_bindings_monero.g.dart b/impls/monero.dart/lib/src/generated_bindings_monero.g.dart
new file mode 100644
index 0000000..3733f8d
--- /dev/null
+++ b/impls/monero.dart/lib/src/generated_bindings_monero.g.dart
@@ -0,0 +1,5417 @@
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `package:ffigen`.
+// ignore_for_file: type=lint
+import 'dart:ffi' as ffi;
+
+/// monero_c bindings
+class MoneroC {
+  /// Holds the symbol lookup function.
+  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
+      _lookup;
+
+  /// The symbols are looked up in [dynamicLibrary].
+  MoneroC(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup;
+
+  /// The symbols are looked up with [lookup].
+  MoneroC.fromLookup(
+      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
+          lookup)
+      : _lookup = lookup;
+
+  int MONERO_PendingTransaction_status(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_status(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_statusPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_PendingTransaction_status');
+  late final _MONERO_PendingTransaction_status =
+      _MONERO_PendingTransaction_statusPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_errorString(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_errorString(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_PendingTransaction_errorString');
+  late final _MONERO_PendingTransaction_errorString =
+      _MONERO_PendingTransaction_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_PendingTransaction_commit(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> filename,
+    bool overwrite,
+  ) {
+    return _MONERO_PendingTransaction_commit(
+      pendingTx_ptr,
+      filename,
+      overwrite,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_commitPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('MONERO_PendingTransaction_commit');
+  late final _MONERO_PendingTransaction_commit =
+      _MONERO_PendingTransaction_commitPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_commitUR(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    int max_fragment_length,
+  ) {
+    return _MONERO_PendingTransaction_commitUR(
+      pendingTx_ptr,
+      max_fragment_length,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_commitURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_PendingTransaction_commitUR');
+  late final _MONERO_PendingTransaction_commitUR =
+      _MONERO_PendingTransaction_commitURPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_PendingTransaction_amount(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_amount(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_amountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_PendingTransaction_amount');
+  late final _MONERO_PendingTransaction_amount =
+      _MONERO_PendingTransaction_amountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_PendingTransaction_dust(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_dust(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_dustPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_PendingTransaction_dust');
+  late final _MONERO_PendingTransaction_dust =
+      _MONERO_PendingTransaction_dustPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_PendingTransaction_fee(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_fee(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_feePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_PendingTransaction_fee');
+  late final _MONERO_PendingTransaction_fee = _MONERO_PendingTransaction_feePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_txid(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_PendingTransaction_txid(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_txidPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_PendingTransaction_txid');
+  late final _MONERO_PendingTransaction_txid =
+      _MONERO_PendingTransaction_txidPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_PendingTransaction_txCount(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_txCount(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_txCountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_PendingTransaction_txCount');
+  late final _MONERO_PendingTransaction_txCount =
+      _MONERO_PendingTransaction_txCountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_subaddrAccount(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_PendingTransaction_subaddrAccount(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_subaddrAccountPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'MONERO_PendingTransaction_subaddrAccount');
+  late final _MONERO_PendingTransaction_subaddrAccount =
+      _MONERO_PendingTransaction_subaddrAccountPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_subaddrIndices(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_PendingTransaction_subaddrIndices(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_subaddrIndicesPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'MONERO_PendingTransaction_subaddrIndices');
+  late final _MONERO_PendingTransaction_subaddrIndices =
+      _MONERO_PendingTransaction_subaddrIndicesPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_multisigSignData(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_multisigSignData(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_multisigSignDataPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'MONERO_PendingTransaction_multisigSignData');
+  late final _MONERO_PendingTransaction_multisigSignData =
+      _MONERO_PendingTransaction_multisigSignDataPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_PendingTransaction_signMultisigTx(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _MONERO_PendingTransaction_signMultisigTx(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_signMultisigTxPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_PendingTransaction_signMultisigTx');
+  late final _MONERO_PendingTransaction_signMultisigTx =
+      _MONERO_PendingTransaction_signMultisigTxPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_signersKeys(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_PendingTransaction_signersKeys(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_signersKeysPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_PendingTransaction_signersKeys');
+  late final _MONERO_PendingTransaction_signersKeys =
+      _MONERO_PendingTransaction_signersKeysPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_PendingTransaction_hex(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_PendingTransaction_hex(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_PendingTransaction_hexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_PendingTransaction_hex');
+  late final _MONERO_PendingTransaction_hex =
+      _MONERO_PendingTransaction_hexPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_UnsignedTransaction_status(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _MONERO_UnsignedTransaction_status(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_statusPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_UnsignedTransaction_status');
+  late final _MONERO_UnsignedTransaction_status =
+      _MONERO_UnsignedTransaction_statusPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_errorString(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _MONERO_UnsignedTransaction_errorString(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_errorStringPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'MONERO_UnsignedTransaction_errorString');
+  late final _MONERO_UnsignedTransaction_errorString =
+      _MONERO_UnsignedTransaction_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_amount(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_UnsignedTransaction_amount(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_amountPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_UnsignedTransaction_amount');
+  late final _MONERO_UnsignedTransaction_amount =
+      _MONERO_UnsignedTransaction_amountPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_fee(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_UnsignedTransaction_fee(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_feePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_UnsignedTransaction_fee');
+  late final _MONERO_UnsignedTransaction_fee =
+      _MONERO_UnsignedTransaction_feePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_mixin(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_UnsignedTransaction_mixin(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_mixinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_UnsignedTransaction_mixin');
+  late final _MONERO_UnsignedTransaction_mixin =
+      _MONERO_UnsignedTransaction_mixinPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_confirmationMessage(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _MONERO_UnsignedTransaction_confirmationMessage(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_confirmationMessagePtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'MONERO_UnsignedTransaction_confirmationMessage');
+  late final _MONERO_UnsignedTransaction_confirmationMessage =
+      _MONERO_UnsignedTransaction_confirmationMessagePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_paymentId(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_UnsignedTransaction_paymentId(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_paymentIdPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_UnsignedTransaction_paymentId');
+  late final _MONERO_UnsignedTransaction_paymentId =
+      _MONERO_UnsignedTransaction_paymentIdPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_recipientAddress(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_UnsignedTransaction_recipientAddress(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_recipientAddressPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'MONERO_UnsignedTransaction_recipientAddress');
+  late final _MONERO_UnsignedTransaction_recipientAddress =
+      _MONERO_UnsignedTransaction_recipientAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_UnsignedTransaction_minMixinCount(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _MONERO_UnsignedTransaction_minMixinCount(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_minMixinCountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_UnsignedTransaction_minMixinCount');
+  late final _MONERO_UnsignedTransaction_minMixinCount =
+      _MONERO_UnsignedTransaction_minMixinCountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_UnsignedTransaction_txCount(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _MONERO_UnsignedTransaction_txCount(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_txCountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_UnsignedTransaction_txCount');
+  late final _MONERO_UnsignedTransaction_txCount =
+      _MONERO_UnsignedTransaction_txCountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_UnsignedTransaction_sign(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> signedFileName,
+  ) {
+    return _MONERO_UnsignedTransaction_sign(
+      unsignedTx_ptr,
+      signedFileName,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_signPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_UnsignedTransaction_sign');
+  late final _MONERO_UnsignedTransaction_sign =
+      _MONERO_UnsignedTransaction_signPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_UnsignedTransaction_signUR(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    int max_fragment_length,
+  ) {
+    return _MONERO_UnsignedTransaction_signUR(
+      unsignedTx_ptr,
+      max_fragment_length,
+    );
+  }
+
+  late final _MONERO_UnsignedTransaction_signURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_UnsignedTransaction_signUR');
+  late final _MONERO_UnsignedTransaction_signUR =
+      _MONERO_UnsignedTransaction_signURPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_TransactionInfo_direction(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_direction(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_directionPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_direction');
+  late final _MONERO_TransactionInfo_direction =
+      _MONERO_TransactionInfo_directionPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_TransactionInfo_isPending(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_isPending(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_isPendingPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_isPending');
+  late final _MONERO_TransactionInfo_isPending =
+      _MONERO_TransactionInfo_isPendingPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_TransactionInfo_isFailed(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_isFailed(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_isFailedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_isFailed');
+  late final _MONERO_TransactionInfo_isFailed =
+      _MONERO_TransactionInfo_isFailedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_TransactionInfo_isCoinbase(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_isCoinbase(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_isCoinbasePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_isCoinbase');
+  late final _MONERO_TransactionInfo_isCoinbase =
+      _MONERO_TransactionInfo_isCoinbasePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_amount(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_amount(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_amountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_amount');
+  late final _MONERO_TransactionInfo_amount = _MONERO_TransactionInfo_amountPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_fee(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_fee(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_feePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_fee');
+  late final _MONERO_TransactionInfo_fee = _MONERO_TransactionInfo_feePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_blockHeight(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_blockHeight(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_blockHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_blockHeight');
+  late final _MONERO_TransactionInfo_blockHeight =
+      _MONERO_TransactionInfo_blockHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_TransactionInfo_description(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_description(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_descriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_TransactionInfo_description');
+  late final _MONERO_TransactionInfo_description =
+      _MONERO_TransactionInfo_descriptionPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_TransactionInfo_subaddrIndex(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_TransactionInfo_subaddrIndex(
+      txInfo_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_subaddrIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_TransactionInfo_subaddrIndex');
+  late final _MONERO_TransactionInfo_subaddrIndex =
+      _MONERO_TransactionInfo_subaddrIndexPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_TransactionInfo_subaddrAccount(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_subaddrAccount(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_subaddrAccountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_subaddrAccount');
+  late final _MONERO_TransactionInfo_subaddrAccount =
+      _MONERO_TransactionInfo_subaddrAccountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_TransactionInfo_label(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_label(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_labelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_TransactionInfo_label');
+  late final _MONERO_TransactionInfo_label = _MONERO_TransactionInfo_labelPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_confirmations(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_confirmations(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_confirmationsPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_confirmations');
+  late final _MONERO_TransactionInfo_confirmations =
+      _MONERO_TransactionInfo_confirmationsPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_unlockTime(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_unlockTime(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_unlockTimePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_unlockTime');
+  late final _MONERO_TransactionInfo_unlockTime =
+      _MONERO_TransactionInfo_unlockTimePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_TransactionInfo_hash(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_hash(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_hashPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_TransactionInfo_hash');
+  late final _MONERO_TransactionInfo_hash = _MONERO_TransactionInfo_hashPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_timestamp(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_timestamp(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_timestampPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_timestamp');
+  late final _MONERO_TransactionInfo_timestamp =
+      _MONERO_TransactionInfo_timestampPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_TransactionInfo_paymentId(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_paymentId(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_paymentIdPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_TransactionInfo_paymentId');
+  late final _MONERO_TransactionInfo_paymentId =
+      _MONERO_TransactionInfo_paymentIdPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_transfers_count(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _MONERO_TransactionInfo_transfers_count(
+      txInfo_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_transfers_countPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionInfo_transfers_count');
+  late final _MONERO_TransactionInfo_transfers_count =
+      _MONERO_TransactionInfo_transfers_countPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_TransactionInfo_transfers_amount(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+    int index,
+  ) {
+    return _MONERO_TransactionInfo_transfers_amount(
+      txInfo_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_transfers_amountPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'MONERO_TransactionInfo_transfers_amount');
+  late final _MONERO_TransactionInfo_transfers_amount =
+      _MONERO_TransactionInfo_transfers_amountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_TransactionInfo_transfers_address(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+    int address,
+  ) {
+    return _MONERO_TransactionInfo_transfers_address(
+      txInfo_ptr,
+      address,
+    );
+  }
+
+  late final _MONERO_TransactionInfo_transfers_addressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_TransactionInfo_transfers_address');
+  late final _MONERO_TransactionInfo_transfers_address =
+      _MONERO_TransactionInfo_transfers_addressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_TransactionHistory_count(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+  ) {
+    return _MONERO_TransactionHistory_count(
+      txHistory_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionHistory_countPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionHistory_count');
+  late final _MONERO_TransactionHistory_count =
+      _MONERO_TransactionHistory_countPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_TransactionHistory_transaction(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+    int index,
+  ) {
+    return _MONERO_TransactionHistory_transaction(
+      txHistory_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_TransactionHistory_transactionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_TransactionHistory_transaction');
+  late final _MONERO_TransactionHistory_transaction =
+      _MONERO_TransactionHistory_transactionPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_TransactionHistory_transactionById(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+    ffi.Pointer<ffi.Char> id,
+  ) {
+    return _MONERO_TransactionHistory_transactionById(
+      txHistory_ptr,
+      id,
+    );
+  }
+
+  late final _MONERO_TransactionHistory_transactionByIdPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Void> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'MONERO_TransactionHistory_transactionById');
+  late final _MONERO_TransactionHistory_transactionById =
+      _MONERO_TransactionHistory_transactionByIdPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_TransactionHistory_refresh(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+  ) {
+    return _MONERO_TransactionHistory_refresh(
+      txHistory_ptr,
+    );
+  }
+
+  late final _MONERO_TransactionHistory_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_TransactionHistory_refresh');
+  late final _MONERO_TransactionHistory_refresh =
+      _MONERO_TransactionHistory_refreshPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_TransactionHistory_setTxNote(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+    ffi.Pointer<ffi.Char> txid,
+    ffi.Pointer<ffi.Char> note,
+  ) {
+    return _MONERO_TransactionHistory_setTxNote(
+      txHistory_ptr,
+      txid,
+      note,
+    );
+  }
+
+  late final _MONERO_TransactionHistory_setTxNotePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_TransactionHistory_setTxNote');
+  late final _MONERO_TransactionHistory_setTxNote =
+      _MONERO_TransactionHistory_setTxNotePtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_AddressBookRow_extra(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _MONERO_AddressBookRow_extra(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBookRow_extraPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_AddressBookRow_extra');
+  late final _MONERO_AddressBookRow_extra = _MONERO_AddressBookRow_extraPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_AddressBookRow_getAddress(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _MONERO_AddressBookRow_getAddress(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBookRow_getAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_AddressBookRow_getAddress');
+  late final _MONERO_AddressBookRow_getAddress =
+      _MONERO_AddressBookRow_getAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_AddressBookRow_getDescription(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _MONERO_AddressBookRow_getDescription(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBookRow_getDescriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_AddressBookRow_getDescription');
+  late final _MONERO_AddressBookRow_getDescription =
+      _MONERO_AddressBookRow_getDescriptionPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_AddressBookRow_getPaymentId(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _MONERO_AddressBookRow_getPaymentId(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBookRow_getPaymentIdPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_AddressBookRow_getPaymentId');
+  late final _MONERO_AddressBookRow_getPaymentId =
+      _MONERO_AddressBookRow_getPaymentIdPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_AddressBookRow_getRowId(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _MONERO_AddressBookRow_getRowId(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBookRow_getRowIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_AddressBookRow_getRowId');
+  late final _MONERO_AddressBookRow_getRowId =
+      _MONERO_AddressBookRow_getRowIdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_AddressBook_getAll_size(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _MONERO_AddressBook_getAll_size(
+      addressBook_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBook_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_AddressBook_getAll_size');
+  late final _MONERO_AddressBook_getAll_size =
+      _MONERO_AddressBook_getAll_sizePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_AddressBook_getAll_byIndex(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    int index,
+  ) {
+    return _MONERO_AddressBook_getAll_byIndex(
+      addressBook_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_AddressBook_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_AddressBook_getAll_byIndex');
+  late final _MONERO_AddressBook_getAll_byIndex =
+      _MONERO_AddressBook_getAll_byIndexPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool MONERO_AddressBook_addRow(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    ffi.Pointer<ffi.Char> dst_addr,
+    ffi.Pointer<ffi.Char> payment_id,
+    ffi.Pointer<ffi.Char> description,
+  ) {
+    return _MONERO_AddressBook_addRow(
+      addressBook_ptr,
+      dst_addr,
+      payment_id,
+      description,
+    );
+  }
+
+  late final _MONERO_AddressBook_addRowPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_AddressBook_addRow');
+  late final _MONERO_AddressBook_addRow =
+      _MONERO_AddressBook_addRowPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_AddressBook_deleteRow(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    int rowId,
+  ) {
+    return _MONERO_AddressBook_deleteRow(
+      addressBook_ptr,
+      rowId,
+    );
+  }
+
+  late final _MONERO_AddressBook_deleteRowPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Size)>>(
+      'MONERO_AddressBook_deleteRow');
+  late final _MONERO_AddressBook_deleteRow = _MONERO_AddressBook_deleteRowPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool MONERO_AddressBook_setDescription(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    int rowId,
+    ffi.Pointer<ffi.Char> description,
+  ) {
+    return _MONERO_AddressBook_setDescription(
+      addressBook_ptr,
+      rowId,
+      description,
+    );
+  }
+
+  late final _MONERO_AddressBook_setDescriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Size,
+              ffi.Pointer<ffi.Char>)>>('MONERO_AddressBook_setDescription');
+  late final _MONERO_AddressBook_setDescription =
+      _MONERO_AddressBook_setDescriptionPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_AddressBook_refresh(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _MONERO_AddressBook_refresh(
+      addressBook_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBook_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_AddressBook_refresh');
+  late final _MONERO_AddressBook_refresh = _MONERO_AddressBook_refreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_AddressBook_errorString(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _MONERO_AddressBook_errorString(
+      addressBook_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBook_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_AddressBook_errorString');
+  late final _MONERO_AddressBook_errorString =
+      _MONERO_AddressBook_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_AddressBook_errorCode(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _MONERO_AddressBook_errorCode(
+      addressBook_ptr,
+    );
+  }
+
+  late final _MONERO_AddressBook_errorCodePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_AddressBook_errorCode');
+  late final _MONERO_AddressBook_errorCode = _MONERO_AddressBook_errorCodePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_AddressBook_lookupPaymentID(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    ffi.Pointer<ffi.Char> payment_id,
+  ) {
+    return _MONERO_AddressBook_lookupPaymentID(
+      addressBook_ptr,
+      payment_id,
+    );
+  }
+
+  late final _MONERO_AddressBook_lookupPaymentIDPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Int Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_AddressBook_lookupPaymentID');
+  late final _MONERO_AddressBook_lookupPaymentID =
+      _MONERO_AddressBook_lookupPaymentIDPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_CoinsInfo_blockHeight(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_blockHeight(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_blockHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_blockHeight');
+  late final _MONERO_CoinsInfo_blockHeight = _MONERO_CoinsInfo_blockHeightPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_CoinsInfo_hash(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_hash(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_hashPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_CoinsInfo_hash');
+  late final _MONERO_CoinsInfo_hash = _MONERO_CoinsInfo_hashPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_internalOutputIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_internalOutputIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_internalOutputIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_internalOutputIndex');
+  late final _MONERO_CoinsInfo_internalOutputIndex =
+      _MONERO_CoinsInfo_internalOutputIndexPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_globalOutputIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_globalOutputIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_globalOutputIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_globalOutputIndex');
+  late final _MONERO_CoinsInfo_globalOutputIndex =
+      _MONERO_CoinsInfo_globalOutputIndexPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_CoinsInfo_spent(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_spent(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_spentPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_spent');
+  late final _MONERO_CoinsInfo_spent = _MONERO_CoinsInfo_spentPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_CoinsInfo_frozen(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_frozen(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_frozenPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_frozen');
+  late final _MONERO_CoinsInfo_frozen = _MONERO_CoinsInfo_frozenPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_spentHeight(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_spentHeight(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_spentHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_spentHeight');
+  late final _MONERO_CoinsInfo_spentHeight = _MONERO_CoinsInfo_spentHeightPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_amount(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_amount(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_amountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_amount');
+  late final _MONERO_CoinsInfo_amount = _MONERO_CoinsInfo_amountPtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_CoinsInfo_rct(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_rct(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_rctPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_rct');
+  late final _MONERO_CoinsInfo_rct = _MONERO_CoinsInfo_rctPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_CoinsInfo_keyImageKnown(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_keyImageKnown(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_keyImageKnownPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_keyImageKnown');
+  late final _MONERO_CoinsInfo_keyImageKnown =
+      _MONERO_CoinsInfo_keyImageKnownPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_pkIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_pkIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_pkIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_pkIndex');
+  late final _MONERO_CoinsInfo_pkIndex = _MONERO_CoinsInfo_pkIndexPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_subaddrIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_subaddrIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_subaddrIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_subaddrIndex');
+  late final _MONERO_CoinsInfo_subaddrIndex = _MONERO_CoinsInfo_subaddrIndexPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_subaddrAccount(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_subaddrAccount(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_subaddrAccountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_subaddrAccount');
+  late final _MONERO_CoinsInfo_subaddrAccount =
+      _MONERO_CoinsInfo_subaddrAccountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_CoinsInfo_address(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_address(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_addressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_CoinsInfo_address');
+  late final _MONERO_CoinsInfo_address = _MONERO_CoinsInfo_addressPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_CoinsInfo_addressLabel(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_addressLabel(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_addressLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_CoinsInfo_addressLabel');
+  late final _MONERO_CoinsInfo_addressLabel = _MONERO_CoinsInfo_addressLabelPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_CoinsInfo_keyImage(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_keyImage(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_keyImagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_CoinsInfo_keyImage');
+  late final _MONERO_CoinsInfo_keyImage = _MONERO_CoinsInfo_keyImagePtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_CoinsInfo_unlockTime(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_unlockTime(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_unlockTimePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_unlockTime');
+  late final _MONERO_CoinsInfo_unlockTime = _MONERO_CoinsInfo_unlockTimePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_CoinsInfo_unlocked(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_unlocked(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_unlockedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_unlocked');
+  late final _MONERO_CoinsInfo_unlocked = _MONERO_CoinsInfo_unlockedPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_CoinsInfo_pubKey(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_pubKey(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_pubKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_CoinsInfo_pubKey');
+  late final _MONERO_CoinsInfo_pubKey = _MONERO_CoinsInfo_pubKeyPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_CoinsInfo_coinbase(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_coinbase(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_coinbasePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_CoinsInfo_coinbase');
+  late final _MONERO_CoinsInfo_coinbase = _MONERO_CoinsInfo_coinbasePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_CoinsInfo_description(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _MONERO_CoinsInfo_description(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _MONERO_CoinsInfo_descriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_CoinsInfo_description');
+  late final _MONERO_CoinsInfo_description = _MONERO_CoinsInfo_descriptionPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Coins_count(
+    ffi.Pointer<ffi.Void> coins_ptr,
+  ) {
+    return _MONERO_Coins_count(
+      coins_ptr,
+    );
+  }
+
+  late final _MONERO_Coins_countPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Coins_count');
+  late final _MONERO_Coins_count =
+      _MONERO_Coins_countPtr.asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Coins_coin(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _MONERO_Coins_coin(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_Coins_coinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Int)>>('MONERO_Coins_coin');
+  late final _MONERO_Coins_coin = _MONERO_Coins_coinPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_Coins_getAll_size(
+    ffi.Pointer<ffi.Void> coins_ptr,
+  ) {
+    return _MONERO_Coins_getAll_size(
+      coins_ptr,
+    );
+  }
+
+  late final _MONERO_Coins_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Coins_getAll_size');
+  late final _MONERO_Coins_getAll_size = _MONERO_Coins_getAll_sizePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Coins_getAll_byIndex(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _MONERO_Coins_getAll_byIndex(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_Coins_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Int)>>('MONERO_Coins_getAll_byIndex');
+  late final _MONERO_Coins_getAll_byIndex = _MONERO_Coins_getAll_byIndexPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_Coins_refresh(
+    ffi.Pointer<ffi.Void> coins_ptr,
+  ) {
+    return _MONERO_Coins_refresh(
+      coins_ptr,
+    );
+  }
+
+  late final _MONERO_Coins_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Coins_refresh');
+  late final _MONERO_Coins_refresh = _MONERO_Coins_refreshPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Coins_setFrozenByPublicKey(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    ffi.Pointer<ffi.Char> public_key,
+  ) {
+    return _MONERO_Coins_setFrozenByPublicKey(
+      coins_ptr,
+      public_key,
+    );
+  }
+
+  late final _MONERO_Coins_setFrozenByPublicKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Coins_setFrozenByPublicKey');
+  late final _MONERO_Coins_setFrozenByPublicKey =
+      _MONERO_Coins_setFrozenByPublicKeyPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_Coins_setFrozen(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _MONERO_Coins_setFrozen(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_Coins_setFrozenPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'MONERO_Coins_setFrozen');
+  late final _MONERO_Coins_setFrozen = _MONERO_Coins_setFrozenPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_Coins_thaw(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _MONERO_Coins_thaw(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_Coins_thawPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'MONERO_Coins_thaw');
+  late final _MONERO_Coins_thaw = _MONERO_Coins_thawPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_Coins_thawByPublicKey(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    ffi.Pointer<ffi.Char> public_key,
+  ) {
+    return _MONERO_Coins_thawByPublicKey(
+      coins_ptr,
+      public_key,
+    );
+  }
+
+  late final _MONERO_Coins_thawByPublicKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Coins_thawByPublicKey');
+  late final _MONERO_Coins_thawByPublicKey =
+      _MONERO_Coins_thawByPublicKeyPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Coins_isTransferUnlocked(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int unlockTime,
+    int blockHeight,
+  ) {
+    return _MONERO_Coins_isTransferUnlocked(
+      coins_ptr,
+      unlockTime,
+      blockHeight,
+    );
+  }
+
+  late final _MONERO_Coins_isTransferUnlockedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
+              ffi.Uint64)>>('MONERO_Coins_isTransferUnlocked');
+  late final _MONERO_Coins_isTransferUnlocked =
+      _MONERO_Coins_isTransferUnlockedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  void MONERO_Coins_setDescription(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    ffi.Pointer<ffi.Char> public_key,
+    ffi.Pointer<ffi.Char> description,
+  ) {
+    return _MONERO_Coins_setDescription(
+      coins_ptr,
+      public_key,
+      description,
+    );
+  }
+
+  late final _MONERO_Coins_setDescriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Coins_setDescription');
+  late final _MONERO_Coins_setDescription =
+      _MONERO_Coins_setDescriptionPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressRow_extra(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _MONERO_SubaddressRow_extra(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressRow_extraPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_SubaddressRow_extra');
+  late final _MONERO_SubaddressRow_extra = _MONERO_SubaddressRow_extraPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressRow_getAddress(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _MONERO_SubaddressRow_getAddress(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressRow_getAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_SubaddressRow_getAddress');
+  late final _MONERO_SubaddressRow_getAddress =
+      _MONERO_SubaddressRow_getAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressRow_getLabel(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _MONERO_SubaddressRow_getLabel(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressRow_getLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_SubaddressRow_getLabel');
+  late final _MONERO_SubaddressRow_getLabel = _MONERO_SubaddressRow_getLabelPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_SubaddressRow_getRowId(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _MONERO_SubaddressRow_getRowId(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressRow_getRowIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_SubaddressRow_getRowId');
+  late final _MONERO_SubaddressRow_getRowId = _MONERO_SubaddressRow_getRowIdPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Subaddress_getAll_size(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+  ) {
+    return _MONERO_Subaddress_getAll_size(
+      subaddress_ptr,
+    );
+  }
+
+  late final _MONERO_Subaddress_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Subaddress_getAll_size');
+  late final _MONERO_Subaddress_getAll_size = _MONERO_Subaddress_getAll_sizePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Subaddress_getAll_byIndex(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int index,
+  ) {
+    return _MONERO_Subaddress_getAll_byIndex(
+      subaddress_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_Subaddress_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_Subaddress_getAll_byIndex');
+  late final _MONERO_Subaddress_getAll_byIndex =
+      _MONERO_Subaddress_getAll_byIndexPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_Subaddress_addRow(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int accountIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_Subaddress_addRow(
+      subaddress_ptr,
+      accountIndex,
+      label,
+    );
+  }
+
+  late final _MONERO_Subaddress_addRowPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Subaddress_addRow');
+  late final _MONERO_Subaddress_addRow =
+      _MONERO_Subaddress_addRowPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_Subaddress_setLabel(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int accountIndex,
+    int addressIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_Subaddress_setLabel(
+      subaddress_ptr,
+      accountIndex,
+      addressIndex,
+      label,
+    );
+  }
+
+  late final _MONERO_Subaddress_setLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Subaddress_setLabel');
+  late final _MONERO_Subaddress_setLabel =
+      _MONERO_Subaddress_setLabelPtr.asFunction<
+          void Function(
+              ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_Subaddress_refresh(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int accountIndex,
+  ) {
+    return _MONERO_Subaddress_refresh(
+      subaddress_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _MONERO_Subaddress_refreshPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(
+              ffi.Pointer<ffi.Void>, ffi.Uint32)>>('MONERO_Subaddress_refresh');
+  late final _MONERO_Subaddress_refresh = _MONERO_Subaddress_refreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressAccountRow_extra(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _MONERO_SubaddressAccountRow_extra(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccountRow_extraPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_SubaddressAccountRow_extra');
+  late final _MONERO_SubaddressAccountRow_extra =
+      _MONERO_SubaddressAccountRow_extraPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressAccountRow_getAddress(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _MONERO_SubaddressAccountRow_getAddress(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccountRow_getAddressPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'MONERO_SubaddressAccountRow_getAddress');
+  late final _MONERO_SubaddressAccountRow_getAddress =
+      _MONERO_SubaddressAccountRow_getAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressAccountRow_getLabel(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _MONERO_SubaddressAccountRow_getLabel(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccountRow_getLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_SubaddressAccountRow_getLabel');
+  late final _MONERO_SubaddressAccountRow_getLabel =
+      _MONERO_SubaddressAccountRow_getLabelPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressAccountRow_getBalance(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _MONERO_SubaddressAccountRow_getBalance(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccountRow_getBalancePtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'MONERO_SubaddressAccountRow_getBalance');
+  late final _MONERO_SubaddressAccountRow_getBalance =
+      _MONERO_SubaddressAccountRow_getBalancePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_SubaddressAccountRow_getUnlockedBalance(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _MONERO_SubaddressAccountRow_getUnlockedBalance(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccountRow_getUnlockedBalancePtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'MONERO_SubaddressAccountRow_getUnlockedBalance');
+  late final _MONERO_SubaddressAccountRow_getUnlockedBalance =
+      _MONERO_SubaddressAccountRow_getUnlockedBalancePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_SubaddressAccountRow_getRowId(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _MONERO_SubaddressAccountRow_getRowId(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccountRow_getRowIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_SubaddressAccountRow_getRowId');
+  late final _MONERO_SubaddressAccountRow_getRowId =
+      _MONERO_SubaddressAccountRow_getRowIdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_SubaddressAccount_getAll_size(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+  ) {
+    return _MONERO_SubaddressAccount_getAll_size(
+      subaddressAccount_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccount_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_SubaddressAccount_getAll_size');
+  late final _MONERO_SubaddressAccount_getAll_size =
+      _MONERO_SubaddressAccount_getAll_sizePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_SubaddressAccount_getAll_byIndex(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+    int index,
+  ) {
+    return _MONERO_SubaddressAccount_getAll_byIndex(
+      subaddressAccount_ptr,
+      index,
+    );
+  }
+
+  late final _MONERO_SubaddressAccount_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('MONERO_SubaddressAccount_getAll_byIndex');
+  late final _MONERO_SubaddressAccount_getAll_byIndex =
+      _MONERO_SubaddressAccount_getAll_byIndexPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_SubaddressAccount_addRow(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_SubaddressAccount_addRow(
+      subaddressAccount_ptr,
+      label,
+    );
+  }
+
+  late final _MONERO_SubaddressAccount_addRowPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_SubaddressAccount_addRow');
+  late final _MONERO_SubaddressAccount_addRow =
+      _MONERO_SubaddressAccount_addRowPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_SubaddressAccount_setLabel(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+    int accountIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_SubaddressAccount_setLabel(
+      subaddressAccount_ptr,
+      accountIndex,
+      label,
+    );
+  }
+
+  late final _MONERO_SubaddressAccount_setLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('MONERO_SubaddressAccount_setLabel');
+  late final _MONERO_SubaddressAccount_setLabel =
+      _MONERO_SubaddressAccount_setLabelPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_SubaddressAccount_refresh(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+  ) {
+    return _MONERO_SubaddressAccount_refresh(
+      subaddressAccount_ptr,
+    );
+  }
+
+  late final _MONERO_SubaddressAccount_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_SubaddressAccount_refresh');
+  late final _MONERO_SubaddressAccount_refresh =
+      _MONERO_SubaddressAccount_refreshPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_MultisigState_isMultisig(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _MONERO_MultisigState_isMultisig(
+      multisigState_ptr,
+    );
+  }
+
+  late final _MONERO_MultisigState_isMultisigPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_MultisigState_isMultisig');
+  late final _MONERO_MultisigState_isMultisig =
+      _MONERO_MultisigState_isMultisigPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_MultisigState_isReady(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _MONERO_MultisigState_isReady(
+      multisigState_ptr,
+    );
+  }
+
+  late final _MONERO_MultisigState_isReadyPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_MultisigState_isReady');
+  late final _MONERO_MultisigState_isReady = _MONERO_MultisigState_isReadyPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_MultisigState_threshold(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _MONERO_MultisigState_threshold(
+      multisigState_ptr,
+    );
+  }
+
+  late final _MONERO_MultisigState_thresholdPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_MultisigState_threshold');
+  late final _MONERO_MultisigState_threshold =
+      _MONERO_MultisigState_thresholdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_MultisigState_total(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _MONERO_MultisigState_total(
+      multisigState_ptr,
+    );
+  }
+
+  late final _MONERO_MultisigState_totalPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_MultisigState_total');
+  late final _MONERO_MultisigState_total = _MONERO_MultisigState_totalPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_DeviceProgress_progress(
+    ffi.Pointer<ffi.Void> deviceProgress_ptr,
+  ) {
+    return _MONERO_DeviceProgress_progress(
+      deviceProgress_ptr,
+    );
+  }
+
+  late final _MONERO_DeviceProgress_progressPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_DeviceProgress_progress');
+  late final _MONERO_DeviceProgress_progress =
+      _MONERO_DeviceProgress_progressPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_DeviceProgress_indeterminate(
+    ffi.Pointer<ffi.Void> deviceProgress_ptr,
+  ) {
+    return _MONERO_DeviceProgress_indeterminate(
+      deviceProgress_ptr,
+    );
+  }
+
+  late final _MONERO_DeviceProgress_indeterminatePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_DeviceProgress_indeterminate');
+  late final _MONERO_DeviceProgress_indeterminate =
+      _MONERO_DeviceProgress_indeterminatePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_seed(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> seed_offset,
+  ) {
+    return _MONERO_Wallet_seed(
+      wallet_ptr,
+      seed_offset,
+    );
+  }
+
+  late final _MONERO_Wallet_seedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_seed');
+  late final _MONERO_Wallet_seed = _MONERO_Wallet_seedPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(
+          ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getSeedLanguage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getSeedLanguage(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getSeedLanguagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_getSeedLanguage');
+  late final _MONERO_Wallet_getSeedLanguage = _MONERO_Wallet_getSeedLanguagePtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setSeedLanguage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> arg,
+  ) {
+    return _MONERO_Wallet_setSeedLanguage(
+      wallet_ptr,
+      arg,
+    );
+  }
+
+  late final _MONERO_Wallet_setSeedLanguagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setSeedLanguage');
+  late final _MONERO_Wallet_setSeedLanguage =
+      _MONERO_Wallet_setSeedLanguagePtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_status(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_status(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_statusPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_status');
+  late final _MONERO_Wallet_status = _MONERO_Wallet_statusPtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_errorString(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_errorString(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_errorString');
+  late final _MONERO_Wallet_errorString = _MONERO_Wallet_errorStringPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_setPassword(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> password,
+  ) {
+    return _MONERO_Wallet_setPassword(
+      wallet_ptr,
+      password,
+    );
+  }
+
+  late final _MONERO_Wallet_setPasswordPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setPassword');
+  late final _MONERO_Wallet_setPassword =
+      _MONERO_Wallet_setPasswordPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getPassword(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getPassword(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getPasswordPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_getPassword');
+  late final _MONERO_Wallet_getPassword = _MONERO_Wallet_getPasswordPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_setDevicePin(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> pin,
+  ) {
+    return _MONERO_Wallet_setDevicePin(
+      wallet_ptr,
+      pin,
+    );
+  }
+
+  late final _MONERO_Wallet_setDevicePinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setDevicePin');
+  late final _MONERO_Wallet_setDevicePin =
+      _MONERO_Wallet_setDevicePinPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_setDevicePassphrase(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> passphrase,
+  ) {
+    return _MONERO_Wallet_setDevicePassphrase(
+      wallet_ptr,
+      passphrase,
+    );
+  }
+
+  late final _MONERO_Wallet_setDevicePassphrasePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setDevicePassphrase');
+  late final _MONERO_Wallet_setDevicePassphrase =
+      _MONERO_Wallet_setDevicePassphrasePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_address(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+  ) {
+    return _MONERO_Wallet_address(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_addressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
+              ffi.Uint64)>>('MONERO_Wallet_address');
+  late final _MONERO_Wallet_address = _MONERO_Wallet_addressPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_path(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_path(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_pathPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_path');
+  late final _MONERO_Wallet_path = _MONERO_Wallet_pathPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_nettype(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_nettype(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_nettypePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_nettype');
+  late final _MONERO_Wallet_nettype = _MONERO_Wallet_nettypePtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_useForkRules(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int version,
+    int early_blocks,
+  ) {
+    return _MONERO_Wallet_useForkRules(
+      wallet_ptr,
+      version,
+      early_blocks,
+    );
+  }
+
+  late final _MONERO_Wallet_useForkRulesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint8 Function(ffi.Pointer<ffi.Void>, ffi.Uint8,
+              ffi.Int64)>>('MONERO_Wallet_useForkRules');
+  late final _MONERO_Wallet_useForkRules = _MONERO_Wallet_useForkRulesPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_integratedAddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> payment_id,
+  ) {
+    return _MONERO_Wallet_integratedAddress(
+      wallet_ptr,
+      payment_id,
+    );
+  }
+
+  late final _MONERO_Wallet_integratedAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_integratedAddress');
+  late final _MONERO_Wallet_integratedAddress =
+      _MONERO_Wallet_integratedAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_secretViewKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_secretViewKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_secretViewKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_secretViewKey');
+  late final _MONERO_Wallet_secretViewKey = _MONERO_Wallet_secretViewKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_publicViewKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_publicViewKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_publicViewKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_publicViewKey');
+  late final _MONERO_Wallet_publicViewKey = _MONERO_Wallet_publicViewKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_secretSpendKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_secretSpendKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_secretSpendKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_secretSpendKey');
+  late final _MONERO_Wallet_secretSpendKey = _MONERO_Wallet_secretSpendKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_publicSpendKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_publicSpendKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_publicSpendKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_publicSpendKey');
+  late final _MONERO_Wallet_publicSpendKey = _MONERO_Wallet_publicSpendKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_publicMultisigSignerKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_publicMultisigSignerKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_publicMultisigSignerKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_publicMultisigSignerKey');
+  late final _MONERO_Wallet_publicMultisigSignerKey =
+      _MONERO_Wallet_publicMultisigSignerKeyPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_stop(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_stop(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_stopPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_stop');
+  late final _MONERO_Wallet_stop =
+      _MONERO_Wallet_stopPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_store(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> path,
+  ) {
+    return _MONERO_Wallet_store(
+      wallet_ptr,
+      path,
+    );
+  }
+
+  late final _MONERO_Wallet_storePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_store');
+  late final _MONERO_Wallet_store = _MONERO_Wallet_storePtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_filename(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_filename(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_filenamePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_filename');
+  late final _MONERO_Wallet_filename = _MONERO_Wallet_filenamePtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_keysFilename(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_keysFilename(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_keysFilenamePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_keysFilename');
+  late final _MONERO_Wallet_keysFilename = _MONERO_Wallet_keysFilenamePtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_init(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> daemon_address,
+    int upper_transaction_size_limit,
+    ffi.Pointer<ffi.Char> daemon_username,
+    ffi.Pointer<ffi.Char> daemon_password,
+    bool use_ssl,
+    bool lightWallet,
+    ffi.Pointer<ffi.Char> proxy_address,
+  ) {
+    return _MONERO_Wallet_init(
+      wallet_ptr,
+      daemon_address,
+      upper_transaction_size_limit,
+      daemon_username,
+      daemon_password,
+      use_ssl,
+      lightWallet,
+      proxy_address,
+    );
+  }
+
+  late final _MONERO_Wallet_initPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Bool,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_init');
+  late final _MONERO_Wallet_init = _MONERO_Wallet_initPtr.asFunction<
+      bool Function(
+          ffi.Pointer<ffi.Void>,
+          ffi.Pointer<ffi.Char>,
+          int,
+          ffi.Pointer<ffi.Char>,
+          ffi.Pointer<ffi.Char>,
+          bool,
+          bool,
+          ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_createWatchOnly(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+  ) {
+    return _MONERO_Wallet_createWatchOnly(
+      wallet_ptr,
+      path,
+      password,
+      language,
+    );
+  }
+
+  late final _MONERO_Wallet_createWatchOnlyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_createWatchOnly');
+  late final _MONERO_Wallet_createWatchOnly =
+      _MONERO_Wallet_createWatchOnlyPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_Wallet_setRefreshFromBlockHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int refresh_from_block_height,
+  ) {
+    return _MONERO_Wallet_setRefreshFromBlockHeight(
+      wallet_ptr,
+      refresh_from_block_height,
+    );
+  }
+
+  late final _MONERO_Wallet_setRefreshFromBlockHeightPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint64)>>('MONERO_Wallet_setRefreshFromBlockHeight');
+  late final _MONERO_Wallet_setRefreshFromBlockHeight =
+      _MONERO_Wallet_setRefreshFromBlockHeightPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_Wallet_getRefreshFromBlockHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getRefreshFromBlockHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getRefreshFromBlockHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getRefreshFromBlockHeight');
+  late final _MONERO_Wallet_getRefreshFromBlockHeight =
+      _MONERO_Wallet_getRefreshFromBlockHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setRecoveringFromSeed(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool recoveringFromSeed,
+  ) {
+    return _MONERO_Wallet_setRecoveringFromSeed(
+      wallet_ptr,
+      recoveringFromSeed,
+    );
+  }
+
+  late final _MONERO_Wallet_setRecoveringFromSeedPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'MONERO_Wallet_setRecoveringFromSeed');
+  late final _MONERO_Wallet_setRecoveringFromSeed =
+      _MONERO_Wallet_setRecoveringFromSeedPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  void MONERO_Wallet_setRecoveringFromDevice(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool recoveringFromDevice,
+  ) {
+    return _MONERO_Wallet_setRecoveringFromDevice(
+      wallet_ptr,
+      recoveringFromDevice,
+    );
+  }
+
+  late final _MONERO_Wallet_setRecoveringFromDevicePtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'MONERO_Wallet_setRecoveringFromDevice');
+  late final _MONERO_Wallet_setRecoveringFromDevice =
+      _MONERO_Wallet_setRecoveringFromDevicePtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  void MONERO_Wallet_setSubaddressLookahead(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int major,
+    int minor,
+  ) {
+    return _MONERO_Wallet_setSubaddressLookahead(
+      wallet_ptr,
+      major,
+      minor,
+    );
+  }
+
+  late final _MONERO_Wallet_setSubaddressLookaheadPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Uint32)>>('MONERO_Wallet_setSubaddressLookahead');
+  late final _MONERO_Wallet_setSubaddressLookahead =
+      _MONERO_Wallet_setSubaddressLookaheadPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  bool MONERO_Wallet_connectToDaemon(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_connectToDaemon(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_connectToDaemonPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_connectToDaemon');
+  late final _MONERO_Wallet_connectToDaemon = _MONERO_Wallet_connectToDaemonPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_connected(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_connected(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_connectedPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_connected');
+  late final _MONERO_Wallet_connected = _MONERO_Wallet_connectedPtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setTrustedDaemon(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool arg,
+  ) {
+    return _MONERO_Wallet_setTrustedDaemon(
+      wallet_ptr,
+      arg,
+    );
+  }
+
+  late final _MONERO_Wallet_setTrustedDaemonPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'MONERO_Wallet_setTrustedDaemon');
+  late final _MONERO_Wallet_setTrustedDaemon =
+      _MONERO_Wallet_setTrustedDaemonPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  bool MONERO_Wallet_trustedDaemon(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_trustedDaemon(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_trustedDaemonPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_trustedDaemon');
+  late final _MONERO_Wallet_trustedDaemon = _MONERO_Wallet_trustedDaemonPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_setProxy(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _MONERO_Wallet_setProxy(
+      wallet_ptr,
+      address,
+    );
+  }
+
+  late final _MONERO_Wallet_setProxyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setProxy');
+  late final _MONERO_Wallet_setProxy = _MONERO_Wallet_setProxyPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_balance(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _MONERO_Wallet_balance(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_balancePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(
+              ffi.Pointer<ffi.Void>, ffi.Uint32)>>('MONERO_Wallet_balance');
+  late final _MONERO_Wallet_balance = _MONERO_Wallet_balancePtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_Wallet_unlockedBalance(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _MONERO_Wallet_unlockedBalance(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_unlockedBalancePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('MONERO_Wallet_unlockedBalance');
+  late final _MONERO_Wallet_unlockedBalance = _MONERO_Wallet_unlockedBalancePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_Wallet_viewOnlyBalance(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _MONERO_Wallet_viewOnlyBalance(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_viewOnlyBalancePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('MONERO_Wallet_viewOnlyBalance');
+  late final _MONERO_Wallet_viewOnlyBalance = _MONERO_Wallet_viewOnlyBalancePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool MONERO_Wallet_watchOnly(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_watchOnly(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_watchOnlyPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_watchOnly');
+  late final _MONERO_Wallet_watchOnly = _MONERO_Wallet_watchOnlyPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_isDeterministic(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_isDeterministic(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_isDeterministicPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_isDeterministic');
+  late final _MONERO_Wallet_isDeterministic = _MONERO_Wallet_isDeterministicPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_blockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_blockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_blockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_blockChainHeight');
+  late final _MONERO_Wallet_blockChainHeight =
+      _MONERO_Wallet_blockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_approximateBlockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_approximateBlockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_approximateBlockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_approximateBlockChainHeight');
+  late final _MONERO_Wallet_approximateBlockChainHeight =
+      _MONERO_Wallet_approximateBlockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_estimateBlockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_estimateBlockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_estimateBlockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_estimateBlockChainHeight');
+  late final _MONERO_Wallet_estimateBlockChainHeight =
+      _MONERO_Wallet_estimateBlockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_daemonBlockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_daemonBlockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_daemonBlockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_daemonBlockChainHeight');
+  late final _MONERO_Wallet_daemonBlockChainHeight =
+      _MONERO_Wallet_daemonBlockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_daemonBlockChainHeight_cached(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_daemonBlockChainHeight_cached(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_daemonBlockChainHeight_cachedPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_daemonBlockChainHeight_cached');
+  late final _MONERO_Wallet_daemonBlockChainHeight_cached =
+      _MONERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_daemonBlockChainHeight_runThread(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int seconds,
+  ) {
+    return _MONERO_Wallet_daemonBlockChainHeight_runThread(
+      wallet_ptr,
+      seconds,
+    );
+  }
+
+  late final _MONERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'MONERO_Wallet_daemonBlockChainHeight_runThread');
+  late final _MONERO_Wallet_daemonBlockChainHeight_runThread =
+      _MONERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_Wallet_daemonBlockChainTargetHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_daemonBlockChainTargetHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_daemonBlockChainTargetHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_daemonBlockChainTargetHeight');
+  late final _MONERO_Wallet_daemonBlockChainTargetHeight =
+      _MONERO_Wallet_daemonBlockChainTargetHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_synchronized(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_synchronized(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_synchronizedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_synchronized');
+  late final _MONERO_Wallet_synchronized = _MONERO_Wallet_synchronizedPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_displayAmount(
+    int amount,
+  ) {
+    return _MONERO_Wallet_displayAmount(
+      amount,
+    );
+  }
+
+  late final _MONERO_Wallet_displayAmountPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Uint64)>>(
+          'MONERO_Wallet_displayAmount');
+  late final _MONERO_Wallet_displayAmount = _MONERO_Wallet_displayAmountPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(int)>();
+
+  int MONERO_Wallet_amountFromString(
+    ffi.Pointer<ffi.Char> amount,
+  ) {
+    return _MONERO_Wallet_amountFromString(
+      amount,
+    );
+  }
+
+  late final _MONERO_Wallet_amountFromStringPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Char>)>>(
+          'MONERO_Wallet_amountFromString');
+  late final _MONERO_Wallet_amountFromString =
+      _MONERO_Wallet_amountFromStringPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_amountFromDouble(
+    double amount,
+  ) {
+    return _MONERO_Wallet_amountFromDouble(
+      amount,
+    );
+  }
+
+  late final _MONERO_Wallet_amountFromDoublePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Double)>>(
+          'MONERO_Wallet_amountFromDouble');
+  late final _MONERO_Wallet_amountFromDouble =
+      _MONERO_Wallet_amountFromDoublePtr.asFunction<int Function(double)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_genPaymentId() {
+    return _MONERO_Wallet_genPaymentId();
+  }
+
+  late final _MONERO_Wallet_genPaymentIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
+          'MONERO_Wallet_genPaymentId');
+  late final _MONERO_Wallet_genPaymentId = _MONERO_Wallet_genPaymentIdPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function()>();
+
+  bool MONERO_Wallet_paymentIdValid(
+    ffi.Pointer<ffi.Char> paiment_id,
+  ) {
+    return _MONERO_Wallet_paymentIdValid(
+      paiment_id,
+    );
+  }
+
+  late final _MONERO_Wallet_paymentIdValidPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>)>>(
+          'MONERO_Wallet_paymentIdValid');
+  late final _MONERO_Wallet_paymentIdValid = _MONERO_Wallet_paymentIdValidPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_addressValid(
+    ffi.Pointer<ffi.Char> str,
+    int nettype,
+  ) {
+    return _MONERO_Wallet_addressValid(
+      str,
+      nettype,
+    );
+  }
+
+  late final _MONERO_Wallet_addressValidPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>, ffi.Int)>>(
+      'MONERO_Wallet_addressValid');
+  late final _MONERO_Wallet_addressValid = _MONERO_Wallet_addressValidPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Char>, int)>();
+
+  bool MONERO_Wallet_keyValid(
+    ffi.Pointer<ffi.Char> secret_key_string,
+    ffi.Pointer<ffi.Char> address_string,
+    bool isViewKey,
+    int nettype,
+  ) {
+    return _MONERO_Wallet_keyValid(
+      secret_key_string,
+      address_string,
+      isViewKey,
+      nettype,
+    );
+  }
+
+  late final _MONERO_Wallet_keyValidPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
+              ffi.Bool, ffi.Int)>>('MONERO_Wallet_keyValid');
+  late final _MONERO_Wallet_keyValid = _MONERO_Wallet_keyValidPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_keyValid_error(
+    ffi.Pointer<ffi.Char> secret_key_string,
+    ffi.Pointer<ffi.Char> address_string,
+    bool isViewKey,
+    int nettype,
+  ) {
+    return _MONERO_Wallet_keyValid_error(
+      secret_key_string,
+      address_string,
+      isViewKey,
+      nettype,
+    );
+  }
+
+  late final _MONERO_Wallet_keyValid_errorPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Int)>>('MONERO_Wallet_keyValid_error');
+  late final _MONERO_Wallet_keyValid_error =
+      _MONERO_Wallet_keyValid_errorPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_paymentIdFromAddress(
+    ffi.Pointer<ffi.Char> strarg,
+    int nettype,
+  ) {
+    return _MONERO_Wallet_paymentIdFromAddress(
+      strarg,
+      nettype,
+    );
+  }
+
+  late final _MONERO_Wallet_paymentIdFromAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>,
+              ffi.Int)>>('MONERO_Wallet_paymentIdFromAddress');
+  late final _MONERO_Wallet_paymentIdFromAddress =
+      _MONERO_Wallet_paymentIdFromAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, int)>();
+
+  int MONERO_Wallet_maximumAllowedAmount() {
+    return _MONERO_Wallet_maximumAllowedAmount();
+  }
+
+  late final _MONERO_Wallet_maximumAllowedAmountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function()>>(
+          'MONERO_Wallet_maximumAllowedAmount');
+  late final _MONERO_Wallet_maximumAllowedAmount =
+      _MONERO_Wallet_maximumAllowedAmountPtr.asFunction<int Function()>();
+
+  void MONERO_Wallet_init3(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> argv0,
+    ffi.Pointer<ffi.Char> default_log_base_name,
+    ffi.Pointer<ffi.Char> log_path,
+    bool console,
+  ) {
+    return _MONERO_Wallet_init3(
+      wallet_ptr,
+      argv0,
+      default_log_base_name,
+      log_path,
+      console,
+    );
+  }
+
+  late final _MONERO_Wallet_init3Ptr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('MONERO_Wallet_init3');
+  late final _MONERO_Wallet_init3 = _MONERO_Wallet_init3Ptr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+          ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getPolyseed(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> passphrase,
+  ) {
+    return _MONERO_Wallet_getPolyseed(
+      wallet_ptr,
+      passphrase,
+    );
+  }
+
+  late final _MONERO_Wallet_getPolyseedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_getPolyseed');
+  late final _MONERO_Wallet_getPolyseed =
+      _MONERO_Wallet_getPolyseedPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_createPolyseed(
+    ffi.Pointer<ffi.Char> language,
+  ) {
+    return _MONERO_Wallet_createPolyseed(
+      language,
+    );
+  }
+
+  late final _MONERO_Wallet_createPolyseedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_createPolyseed');
+  late final _MONERO_Wallet_createPolyseed = _MONERO_Wallet_createPolyseedPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_Wallet_startRefresh(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_startRefresh(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_startRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_startRefresh');
+  late final _MONERO_Wallet_startRefresh = _MONERO_Wallet_startRefreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_pauseRefresh(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_pauseRefresh(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_pauseRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_pauseRefresh');
+  late final _MONERO_Wallet_pauseRefresh = _MONERO_Wallet_pauseRefreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_refresh(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_refresh(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_refresh');
+  late final _MONERO_Wallet_refresh = _MONERO_Wallet_refreshPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_refreshAsync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_refreshAsync(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_refreshAsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_refreshAsync');
+  late final _MONERO_Wallet_refreshAsync = _MONERO_Wallet_refreshAsyncPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_rescanBlockchain(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_rescanBlockchain(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_rescanBlockchainPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_rescanBlockchain');
+  late final _MONERO_Wallet_rescanBlockchain =
+      _MONERO_Wallet_rescanBlockchainPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_rescanBlockchainAsync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_rescanBlockchainAsync(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_rescanBlockchainAsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_rescanBlockchainAsync');
+  late final _MONERO_Wallet_rescanBlockchainAsync =
+      _MONERO_Wallet_rescanBlockchainAsyncPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setAutoRefreshInterval(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int millis,
+  ) {
+    return _MONERO_Wallet_setAutoRefreshInterval(
+      wallet_ptr,
+      millis,
+    );
+  }
+
+  late final _MONERO_Wallet_setAutoRefreshIntervalPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'MONERO_Wallet_setAutoRefreshInterval');
+  late final _MONERO_Wallet_setAutoRefreshInterval =
+      _MONERO_Wallet_setAutoRefreshIntervalPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int MONERO_Wallet_autoRefreshInterval(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_autoRefreshInterval(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_autoRefreshIntervalPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_autoRefreshInterval');
+  late final _MONERO_Wallet_autoRefreshInterval =
+      _MONERO_Wallet_autoRefreshIntervalPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_addSubaddressAccount(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_Wallet_addSubaddressAccount(
+      wallet_ptr,
+      label,
+    );
+  }
+
+  late final _MONERO_Wallet_addSubaddressAccountPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_addSubaddressAccount');
+  late final _MONERO_Wallet_addSubaddressAccount =
+      _MONERO_Wallet_addSubaddressAccountPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_numSubaddressAccounts(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_numSubaddressAccounts(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_numSubaddressAccountsPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_numSubaddressAccounts');
+  late final _MONERO_Wallet_numSubaddressAccounts =
+      _MONERO_Wallet_numSubaddressAccountsPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_numSubaddresses(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _MONERO_Wallet_numSubaddresses(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_numSubaddressesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Size Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('MONERO_Wallet_numSubaddresses');
+  late final _MONERO_Wallet_numSubaddresses = _MONERO_Wallet_numSubaddressesPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_Wallet_addSubaddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_Wallet_addSubaddress(
+      wallet_ptr,
+      accountIndex,
+      label,
+    );
+  }
+
+  late final _MONERO_Wallet_addSubaddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_addSubaddress');
+  late final _MONERO_Wallet_addSubaddress =
+      _MONERO_Wallet_addSubaddressPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getSubaddressLabel(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+  ) {
+    return _MONERO_Wallet_getSubaddressLabel(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_getSubaddressLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Uint32)>>('MONERO_Wallet_getSubaddressLabel');
+  late final _MONERO_Wallet_getSubaddressLabel =
+      _MONERO_Wallet_getSubaddressLabelPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  void MONERO_Wallet_setSubaddressLabel(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _MONERO_Wallet_setSubaddressLabel(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+      label,
+    );
+  }
+
+  late final _MONERO_Wallet_setSubaddressLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setSubaddressLabel');
+  late final _MONERO_Wallet_setSubaddressLabel =
+      _MONERO_Wallet_setSubaddressLabelPtr.asFunction<
+          void Function(
+              ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_multisig(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_multisig(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_multisigPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_multisig');
+  late final _MONERO_Wallet_multisig = _MONERO_Wallet_multisigPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getMultisigInfo(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getMultisigInfo(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getMultisigInfoPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_getMultisigInfo');
+  late final _MONERO_Wallet_getMultisigInfo = _MONERO_Wallet_getMultisigInfoPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_makeMultisig(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> info,
+    ffi.Pointer<ffi.Char> info_separator,
+    int threshold,
+  ) {
+    return _MONERO_Wallet_makeMultisig(
+      wallet_ptr,
+      info,
+      info_separator,
+      threshold,
+    );
+  }
+
+  late final _MONERO_Wallet_makeMultisigPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint32)>>('MONERO_Wallet_makeMultisig');
+  late final _MONERO_Wallet_makeMultisig =
+      _MONERO_Wallet_makeMultisigPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_exchangeMultisigKeys(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> info,
+    ffi.Pointer<ffi.Char> info_separator,
+    bool force_update_use_with_caution,
+  ) {
+    return _MONERO_Wallet_exchangeMultisigKeys(
+      wallet_ptr,
+      info,
+      info_separator,
+      force_update_use_with_caution,
+    );
+  }
+
+  late final _MONERO_Wallet_exchangeMultisigKeysPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('MONERO_Wallet_exchangeMultisigKeys');
+  late final _MONERO_Wallet_exchangeMultisigKeys =
+      _MONERO_Wallet_exchangeMultisigKeysPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_exportMultisigImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_Wallet_exportMultisigImages(
+      wallet_ptr,
+      separator,
+    );
+  }
+
+  late final _MONERO_Wallet_exportMultisigImagesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_exportMultisigImages');
+  late final _MONERO_Wallet_exportMultisigImages =
+      _MONERO_Wallet_exportMultisigImagesPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_importMultisigImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> info,
+    ffi.Pointer<ffi.Char> info_separator,
+  ) {
+    return _MONERO_Wallet_importMultisigImages(
+      wallet_ptr,
+      info,
+      info_separator,
+    );
+  }
+
+  late final _MONERO_Wallet_importMultisigImagesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Size Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_importMultisigImages');
+  late final _MONERO_Wallet_importMultisigImages =
+      _MONERO_Wallet_importMultisigImagesPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_hasMultisigPartialKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_hasMultisigPartialKeyImages(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_hasMultisigPartialKeyImagesPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_hasMultisigPartialKeyImages');
+  late final _MONERO_Wallet_hasMultisigPartialKeyImages =
+      _MONERO_Wallet_hasMultisigPartialKeyImagesPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_restoreMultisigTransaction(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> signData,
+  ) {
+    return _MONERO_Wallet_restoreMultisigTransaction(
+      wallet_ptr,
+      signData,
+    );
+  }
+
+  late final _MONERO_Wallet_restoreMultisigTransactionPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Void> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'MONERO_Wallet_restoreMultisigTransaction');
+  late final _MONERO_Wallet_restoreMultisigTransaction =
+      _MONERO_Wallet_restoreMultisigTransactionPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_createTransactionMultDest(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> dst_addr_list,
+    ffi.Pointer<ffi.Char> dst_addr_list_separator,
+    ffi.Pointer<ffi.Char> payment_id,
+    bool amount_sweep_all,
+    ffi.Pointer<ffi.Char> amount_list,
+    ffi.Pointer<ffi.Char> amount_list_separator,
+    int mixin_count,
+    int pendingTransactionPriority,
+    int subaddr_account,
+    ffi.Pointer<ffi.Char> preferredInputs,
+    ffi.Pointer<ffi.Char> preferredInputs_separator,
+  ) {
+    return _MONERO_Wallet_createTransactionMultDest(
+      wallet_ptr,
+      dst_addr_list,
+      dst_addr_list_separator,
+      payment_id,
+      amount_sweep_all,
+      amount_list,
+      amount_list_separator,
+      mixin_count,
+      pendingTransactionPriority,
+      subaddr_account,
+      preferredInputs,
+      preferredInputs_separator,
+    );
+  }
+
+  late final _MONERO_Wallet_createTransactionMultDestPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Void> Function(
+                  ffi.Pointer<ffi.Void>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Bool,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Uint32,
+                  ffi.Int,
+                  ffi.Uint32,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>)>>(
+      'MONERO_Wallet_createTransactionMultDest');
+  late final _MONERO_Wallet_createTransactionMultDest =
+      _MONERO_Wallet_createTransactionMultDestPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              bool,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_createTransaction(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> dst_addr,
+    ffi.Pointer<ffi.Char> payment_id,
+    int amount,
+    int mixin_count,
+    int pendingTransactionPriority,
+    int subaddr_account,
+    ffi.Pointer<ffi.Char> preferredInputs,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_Wallet_createTransaction(
+      wallet_ptr,
+      dst_addr,
+      payment_id,
+      amount,
+      mixin_count,
+      pendingTransactionPriority,
+      subaddr_account,
+      preferredInputs,
+      separator,
+    );
+  }
+
+  late final _MONERO_Wallet_createTransactionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64,
+              ffi.Uint32,
+              ffi.Int,
+              ffi.Uint32,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_createTransaction');
+  late final _MONERO_Wallet_createTransaction =
+      _MONERO_Wallet_createTransactionPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_loadUnsignedTx(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> unsigned_filename,
+  ) {
+    return _MONERO_Wallet_loadUnsignedTx(
+      wallet_ptr,
+      unsigned_filename,
+    );
+  }
+
+  late final _MONERO_Wallet_loadUnsignedTxPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_loadUnsignedTx');
+  late final _MONERO_Wallet_loadUnsignedTx =
+      _MONERO_Wallet_loadUnsignedTxPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_loadUnsignedTxUR(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> input,
+  ) {
+    return _MONERO_Wallet_loadUnsignedTxUR(
+      wallet_ptr,
+      input,
+    );
+  }
+
+  late final _MONERO_Wallet_loadUnsignedTxURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_loadUnsignedTxUR');
+  late final _MONERO_Wallet_loadUnsignedTxUR =
+      _MONERO_Wallet_loadUnsignedTxURPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_submitTransaction(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> fileName,
+  ) {
+    return _MONERO_Wallet_submitTransaction(
+      wallet_ptr,
+      fileName,
+    );
+  }
+
+  late final _MONERO_Wallet_submitTransactionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_submitTransaction');
+  late final _MONERO_Wallet_submitTransaction =
+      _MONERO_Wallet_submitTransactionPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_submitTransactionUR(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> input,
+  ) {
+    return _MONERO_Wallet_submitTransactionUR(
+      wallet_ptr,
+      input,
+    );
+  }
+
+  late final _MONERO_Wallet_submitTransactionURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_submitTransactionUR');
+  late final _MONERO_Wallet_submitTransactionUR =
+      _MONERO_Wallet_submitTransactionURPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_hasUnknownKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_hasUnknownKeyImages(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_hasUnknownKeyImagesPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_hasUnknownKeyImages');
+  late final _MONERO_Wallet_hasUnknownKeyImages =
+      _MONERO_Wallet_hasUnknownKeyImagesPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_exportKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+    bool all,
+  ) {
+    return _MONERO_Wallet_exportKeyImages(
+      wallet_ptr,
+      filename,
+      all,
+    );
+  }
+
+  late final _MONERO_Wallet_exportKeyImagesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('MONERO_Wallet_exportKeyImages');
+  late final _MONERO_Wallet_exportKeyImages =
+      _MONERO_Wallet_exportKeyImagesPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_exportKeyImagesUR(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int max_fragment_length,
+    bool all,
+  ) {
+    return _MONERO_Wallet_exportKeyImagesUR(
+      wallet_ptr,
+      max_fragment_length,
+      all,
+    );
+  }
+
+  late final _MONERO_Wallet_exportKeyImagesURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Size,
+              ffi.Bool)>>('MONERO_Wallet_exportKeyImagesUR');
+  late final _MONERO_Wallet_exportKeyImagesUR =
+      _MONERO_Wallet_exportKeyImagesURPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, bool)>();
+
+  bool MONERO_Wallet_importKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+  ) {
+    return _MONERO_Wallet_importKeyImages(
+      wallet_ptr,
+      filename,
+    );
+  }
+
+  late final _MONERO_Wallet_importKeyImagesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_importKeyImages');
+  late final _MONERO_Wallet_importKeyImages =
+      _MONERO_Wallet_importKeyImagesPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_importKeyImagesUR(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> input,
+  ) {
+    return _MONERO_Wallet_importKeyImagesUR(
+      wallet_ptr,
+      input,
+    );
+  }
+
+  late final _MONERO_Wallet_importKeyImagesURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_importKeyImagesUR');
+  late final _MONERO_Wallet_importKeyImagesUR =
+      _MONERO_Wallet_importKeyImagesURPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_exportOutputs(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+    bool all,
+  ) {
+    return _MONERO_Wallet_exportOutputs(
+      wallet_ptr,
+      filename,
+      all,
+    );
+  }
+
+  late final _MONERO_Wallet_exportOutputsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('MONERO_Wallet_exportOutputs');
+  late final _MONERO_Wallet_exportOutputs =
+      _MONERO_Wallet_exportOutputsPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_exportOutputsUR(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int max_fragment_length,
+    bool all,
+  ) {
+    return _MONERO_Wallet_exportOutputsUR(
+      wallet_ptr,
+      max_fragment_length,
+      all,
+    );
+  }
+
+  late final _MONERO_Wallet_exportOutputsURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Size,
+              ffi.Bool)>>('MONERO_Wallet_exportOutputsUR');
+  late final _MONERO_Wallet_exportOutputsUR =
+      _MONERO_Wallet_exportOutputsURPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, bool)>();
+
+  bool MONERO_Wallet_importOutputs(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+  ) {
+    return _MONERO_Wallet_importOutputs(
+      wallet_ptr,
+      filename,
+    );
+  }
+
+  late final _MONERO_Wallet_importOutputsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_importOutputs');
+  late final _MONERO_Wallet_importOutputs =
+      _MONERO_Wallet_importOutputsPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_importOutputsUR(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> input,
+  ) {
+    return _MONERO_Wallet_importOutputsUR(
+      wallet_ptr,
+      input,
+    );
+  }
+
+  late final _MONERO_Wallet_importOutputsURPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_importOutputsUR');
+  late final _MONERO_Wallet_importOutputsUR =
+      _MONERO_Wallet_importOutputsURPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_setupBackgroundSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int background_sync_type,
+    ffi.Pointer<ffi.Char> wallet_password,
+    ffi.Pointer<ffi.Char> background_cache_password,
+  ) {
+    return _MONERO_Wallet_setupBackgroundSync(
+      wallet_ptr,
+      background_sync_type,
+      wallet_password,
+      background_cache_password,
+    );
+  }
+
+  late final _MONERO_Wallet_setupBackgroundSyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setupBackgroundSync');
+  late final _MONERO_Wallet_setupBackgroundSync =
+      _MONERO_Wallet_setupBackgroundSyncPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_Wallet_getBackgroundSyncType(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getBackgroundSyncType(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getBackgroundSyncTypePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getBackgroundSyncType');
+  late final _MONERO_Wallet_getBackgroundSyncType =
+      _MONERO_Wallet_getBackgroundSyncTypePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_startBackgroundSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_startBackgroundSync(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_startBackgroundSyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_startBackgroundSync');
+  late final _MONERO_Wallet_startBackgroundSync =
+      _MONERO_Wallet_startBackgroundSyncPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_stopBackgroundSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> wallet_password,
+  ) {
+    return _MONERO_Wallet_stopBackgroundSync(
+      wallet_ptr,
+      wallet_password,
+    );
+  }
+
+  late final _MONERO_Wallet_stopBackgroundSyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_stopBackgroundSync');
+  late final _MONERO_Wallet_stopBackgroundSync =
+      _MONERO_Wallet_stopBackgroundSyncPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_isBackgroundSyncing(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_isBackgroundSyncing(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_isBackgroundSyncingPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_isBackgroundSyncing');
+  late final _MONERO_Wallet_isBackgroundSyncing =
+      _MONERO_Wallet_isBackgroundSyncingPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_isBackgroundWallet(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_isBackgroundWallet(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_isBackgroundWalletPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_isBackgroundWallet');
+  late final _MONERO_Wallet_isBackgroundWallet =
+      _MONERO_Wallet_isBackgroundWalletPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_history(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_history(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_historyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_history');
+  late final _MONERO_Wallet_history = _MONERO_Wallet_historyPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_addressBook(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_addressBook(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_addressBookPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_addressBook');
+  late final _MONERO_Wallet_addressBook = _MONERO_Wallet_addressBookPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_coins(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_coins(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_coinsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_coins');
+  late final _MONERO_Wallet_coins = _MONERO_Wallet_coinsPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_subaddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_subaddress(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_subaddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_subaddress');
+  late final _MONERO_Wallet_subaddress = _MONERO_Wallet_subaddressPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_Wallet_subaddressAccount(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_subaddressAccount(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_subaddressAccountPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_subaddressAccount');
+  late final _MONERO_Wallet_subaddressAccount =
+      _MONERO_Wallet_subaddressAccountPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_defaultMixin(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_defaultMixin(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_defaultMixinPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_defaultMixin');
+  late final _MONERO_Wallet_defaultMixin = _MONERO_Wallet_defaultMixinPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setDefaultMixin(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int arg,
+  ) {
+    return _MONERO_Wallet_setDefaultMixin(
+      wallet_ptr,
+      arg,
+    );
+  }
+
+  late final _MONERO_Wallet_setDefaultMixinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('MONERO_Wallet_setDefaultMixin');
+  late final _MONERO_Wallet_setDefaultMixin = _MONERO_Wallet_setDefaultMixinPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool MONERO_Wallet_setCacheAttribute(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> key,
+    ffi.Pointer<ffi.Char> val,
+  ) {
+    return _MONERO_Wallet_setCacheAttribute(
+      wallet_ptr,
+      key,
+      val,
+    );
+  }
+
+  late final _MONERO_Wallet_setCacheAttributePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setCacheAttribute');
+  late final _MONERO_Wallet_setCacheAttribute =
+      _MONERO_Wallet_setCacheAttributePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getCacheAttribute(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> key,
+  ) {
+    return _MONERO_Wallet_getCacheAttribute(
+      wallet_ptr,
+      key,
+    );
+  }
+
+  late final _MONERO_Wallet_getCacheAttributePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_getCacheAttribute');
+  late final _MONERO_Wallet_getCacheAttribute =
+      _MONERO_Wallet_getCacheAttributePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_setUserNote(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> txid,
+    ffi.Pointer<ffi.Char> note,
+  ) {
+    return _MONERO_Wallet_setUserNote(
+      wallet_ptr,
+      txid,
+      note,
+    );
+  }
+
+  late final _MONERO_Wallet_setUserNotePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_setUserNote');
+  late final _MONERO_Wallet_setUserNote =
+      _MONERO_Wallet_setUserNotePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getUserNote(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> txid,
+  ) {
+    return _MONERO_Wallet_getUserNote(
+      wallet_ptr,
+      txid,
+    );
+  }
+
+  late final _MONERO_Wallet_getUserNotePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_getUserNote');
+  late final _MONERO_Wallet_getUserNote =
+      _MONERO_Wallet_getUserNotePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_getTxKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> txid,
+  ) {
+    return _MONERO_Wallet_getTxKey(
+      wallet_ptr,
+      txid,
+    );
+  }
+
+  late final _MONERO_Wallet_getTxKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_getTxKey');
+  late final _MONERO_Wallet_getTxKey = _MONERO_Wallet_getTxKeyPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(
+          ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_signMessage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> message,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _MONERO_Wallet_signMessage(
+      wallet_ptr,
+      message,
+      address,
+    );
+  }
+
+  late final _MONERO_Wallet_signMessagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_signMessage');
+  late final _MONERO_Wallet_signMessage =
+      _MONERO_Wallet_signMessagePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_verifySignedMessage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> message,
+    ffi.Pointer<ffi.Char> address,
+    ffi.Pointer<ffi.Char> signature,
+  ) {
+    return _MONERO_Wallet_verifySignedMessage(
+      wallet_ptr,
+      message,
+      address,
+      signature,
+    );
+  }
+
+  late final _MONERO_Wallet_verifySignedMessagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_Wallet_verifySignedMessage');
+  late final _MONERO_Wallet_verifySignedMessage =
+      _MONERO_Wallet_verifySignedMessagePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_Wallet_rescanSpent(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_rescanSpent(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_rescanSpentPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_rescanSpent');
+  late final _MONERO_Wallet_rescanSpent = _MONERO_Wallet_rescanSpentPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setOffline(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool offline,
+  ) {
+    return _MONERO_Wallet_setOffline(
+      wallet_ptr,
+      offline,
+    );
+  }
+
+  late final _MONERO_Wallet_setOfflinePtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'MONERO_Wallet_setOffline');
+  late final _MONERO_Wallet_setOffline = _MONERO_Wallet_setOfflinePtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  bool MONERO_Wallet_isOffline(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_isOffline(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_isOfflinePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_isOffline');
+  late final _MONERO_Wallet_isOffline = _MONERO_Wallet_isOfflinePtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_segregatePreForkOutputs(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool segregate,
+  ) {
+    return _MONERO_Wallet_segregatePreForkOutputs(
+      wallet_ptr,
+      segregate,
+    );
+  }
+
+  late final _MONERO_Wallet_segregatePreForkOutputsPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'MONERO_Wallet_segregatePreForkOutputs');
+  late final _MONERO_Wallet_segregatePreForkOutputs =
+      _MONERO_Wallet_segregatePreForkOutputsPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  void MONERO_Wallet_segregationHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int height,
+  ) {
+    return _MONERO_Wallet_segregationHeight(
+      wallet_ptr,
+      height,
+    );
+  }
+
+  late final _MONERO_Wallet_segregationHeightPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint64)>>('MONERO_Wallet_segregationHeight');
+  late final _MONERO_Wallet_segregationHeight =
+      _MONERO_Wallet_segregationHeightPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void MONERO_Wallet_keyReuseMitigation2(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool mitigation,
+  ) {
+    return _MONERO_Wallet_keyReuseMitigation2(
+      wallet_ptr,
+      mitigation,
+    );
+  }
+
+  late final _MONERO_Wallet_keyReuseMitigation2Ptr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'MONERO_Wallet_keyReuseMitigation2');
+  late final _MONERO_Wallet_keyReuseMitigation2 =
+      _MONERO_Wallet_keyReuseMitigation2Ptr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  bool MONERO_Wallet_lockKeysFile(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_lockKeysFile(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_lockKeysFilePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_lockKeysFile');
+  late final _MONERO_Wallet_lockKeysFile = _MONERO_Wallet_lockKeysFilePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_unlockKeysFile(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_unlockKeysFile(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_unlockKeysFilePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_unlockKeysFile');
+  late final _MONERO_Wallet_unlockKeysFile = _MONERO_Wallet_unlockKeysFilePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_isKeysFileLocked(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_isKeysFileLocked(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_isKeysFileLockedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_isKeysFileLocked');
+  late final _MONERO_Wallet_isKeysFileLocked =
+      _MONERO_Wallet_isKeysFileLockedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_getDeviceType(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getDeviceType(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getDeviceTypePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getDeviceType');
+  late final _MONERO_Wallet_getDeviceType = _MONERO_Wallet_getDeviceTypePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_coldKeyImageSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int spent,
+    int unspent,
+  ) {
+    return _MONERO_Wallet_coldKeyImageSync(
+      wallet_ptr,
+      spent,
+      unspent,
+    );
+  }
+
+  late final _MONERO_Wallet_coldKeyImageSyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
+              ffi.Uint64)>>('MONERO_Wallet_coldKeyImageSync');
+  late final _MONERO_Wallet_coldKeyImageSync =
+      _MONERO_Wallet_coldKeyImageSyncPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_Wallet_deviceShowAddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+  ) {
+    return _MONERO_Wallet_deviceShowAddress(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+    );
+  }
+
+  late final _MONERO_Wallet_deviceShowAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Uint32)>>('MONERO_Wallet_deviceShowAddress');
+  late final _MONERO_Wallet_deviceShowAddress =
+      _MONERO_Wallet_deviceShowAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  bool MONERO_Wallet_reconnectDevice(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_reconnectDevice(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_reconnectDevicePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_reconnectDevice');
+  late final _MONERO_Wallet_reconnectDevice = _MONERO_Wallet_reconnectDevicePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_getBytesReceived(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getBytesReceived(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getBytesReceivedPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getBytesReceived');
+  late final _MONERO_Wallet_getBytesReceived =
+      _MONERO_Wallet_getBytesReceivedPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_getBytesSent(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getBytesSent(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getBytesSentPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getBytesSent');
+  late final _MONERO_Wallet_getBytesSent = _MONERO_Wallet_getBytesSentPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_getStateIsConnected(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getStateIsConnected(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getStateIsConnectedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getStateIsConnected');
+  late final _MONERO_Wallet_getStateIsConnected =
+      _MONERO_Wallet_getStateIsConnectedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.UnsignedChar> MONERO_Wallet_getSendToDevice(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getSendToDevice(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getSendToDevicePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.UnsignedChar> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_getSendToDevice');
+  late final _MONERO_Wallet_getSendToDevice =
+      _MONERO_Wallet_getSendToDevicePtr.asFunction<
+          ffi.Pointer<ffi.UnsignedChar> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_getSendToDeviceLength(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getSendToDeviceLength(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getSendToDeviceLengthPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getSendToDeviceLength');
+  late final _MONERO_Wallet_getSendToDeviceLength =
+      _MONERO_Wallet_getSendToDeviceLengthPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.UnsignedChar> MONERO_Wallet_getReceivedFromDevice(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getReceivedFromDevice(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getReceivedFromDevicePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.UnsignedChar> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_Wallet_getReceivedFromDevice');
+  late final _MONERO_Wallet_getReceivedFromDevice =
+      _MONERO_Wallet_getReceivedFromDevicePtr.asFunction<
+          ffi.Pointer<ffi.UnsignedChar> Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_Wallet_getReceivedFromDeviceLength(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getReceivedFromDeviceLength(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getReceivedFromDeviceLengthPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getReceivedFromDeviceLength');
+  late final _MONERO_Wallet_getReceivedFromDeviceLength =
+      _MONERO_Wallet_getReceivedFromDeviceLengthPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_getWaitsForDeviceSend(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getWaitsForDeviceSend(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getWaitsForDeviceSendPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getWaitsForDeviceSend');
+  late final _MONERO_Wallet_getWaitsForDeviceSend =
+      _MONERO_Wallet_getWaitsForDeviceSendPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_Wallet_getWaitsForDeviceReceive(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_Wallet_getWaitsForDeviceReceive(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_Wallet_getWaitsForDeviceReceivePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_Wallet_getWaitsForDeviceReceive');
+  late final _MONERO_Wallet_getWaitsForDeviceReceive =
+      _MONERO_Wallet_getWaitsForDeviceReceivePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_Wallet_setDeviceReceivedData(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.UnsignedChar> data,
+    int len,
+  ) {
+    return _MONERO_Wallet_setDeviceReceivedData(
+      wallet_ptr,
+      data,
+      len,
+    );
+  }
+
+  late final _MONERO_Wallet_setDeviceReceivedDataPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.UnsignedChar>,
+              ffi.Size)>>('MONERO_Wallet_setDeviceReceivedData');
+  late final _MONERO_Wallet_setDeviceReceivedData =
+      _MONERO_Wallet_setDeviceReceivedDataPtr.asFunction<
+          void Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.UnsignedChar>, int)>();
+
+  void MONERO_Wallet_setDeviceSendData(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.UnsignedChar> data,
+    int len,
+  ) {
+    return _MONERO_Wallet_setDeviceSendData(
+      wallet_ptr,
+      data,
+      len,
+    );
+  }
+
+  late final _MONERO_Wallet_setDeviceSendDataPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.UnsignedChar>,
+              ffi.Size)>>('MONERO_Wallet_setDeviceSendData');
+  late final _MONERO_Wallet_setDeviceSendData =
+      _MONERO_Wallet_setDeviceSendDataPtr.asFunction<
+          void Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.UnsignedChar>, int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManager_createWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int networkType,
+  ) {
+    return _MONERO_WalletManager_createWallet(
+      wm_ptr,
+      path,
+      password,
+      language,
+      networkType,
+    );
+  }
+
+  late final _MONERO_WalletManager_createWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int)>>('MONERO_WalletManager_createWallet');
+  late final _MONERO_WalletManager_createWallet =
+      _MONERO_WalletManager_createWalletPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManager_openWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    int networkType,
+  ) {
+    return _MONERO_WalletManager_openWallet(
+      wm_ptr,
+      path,
+      password,
+      networkType,
+    );
+  }
+
+  late final _MONERO_WalletManager_openWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int)>>('MONERO_WalletManager_openWallet');
+  late final _MONERO_WalletManager_openWallet =
+      _MONERO_WalletManager_openWalletPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManager_recoveryWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> mnemonic,
+    int networkType,
+    int restoreHeight,
+    int kdfRounds,
+    ffi.Pointer<ffi.Char> seedOffset,
+  ) {
+    return _MONERO_WalletManager_recoveryWallet(
+      wm_ptr,
+      path,
+      password,
+      mnemonic,
+      networkType,
+      restoreHeight,
+      kdfRounds,
+      seedOffset,
+    );
+  }
+
+  late final _MONERO_WalletManager_recoveryWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Uint64,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>)>>('MONERO_WalletManager_recoveryWallet');
+  late final _MONERO_WalletManager_recoveryWallet =
+      _MONERO_WalletManager_recoveryWalletPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManager_createWalletFromKeys(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int nettype,
+    int restoreHeight,
+    ffi.Pointer<ffi.Char> addressString,
+    ffi.Pointer<ffi.Char> viewKeyString,
+    ffi.Pointer<ffi.Char> spendKeyString,
+    int kdf_rounds,
+  ) {
+    return _MONERO_WalletManager_createWalletFromKeys(
+      wm_ptr,
+      path,
+      password,
+      language,
+      nettype,
+      restoreHeight,
+      addressString,
+      viewKeyString,
+      spendKeyString,
+      kdf_rounds,
+    );
+  }
+
+  late final _MONERO_WalletManager_createWalletFromKeysPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64)>>('MONERO_WalletManager_createWalletFromKeys');
+  late final _MONERO_WalletManager_createWalletFromKeys =
+      _MONERO_WalletManager_createWalletFromKeysPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int)>();
+
+  ffi.Pointer<ffi.Void>
+      MONERO_WalletManager_createDeterministicWalletFromSpendKey(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int nettype,
+    int restoreHeight,
+    ffi.Pointer<ffi.Char> spendKeyString,
+    int kdf_rounds,
+  ) {
+    return _MONERO_WalletManager_createDeterministicWalletFromSpendKey(
+      wm_ptr,
+      path,
+      password,
+      language,
+      nettype,
+      restoreHeight,
+      spendKeyString,
+      kdf_rounds,
+    );
+  }
+
+  late final _MONERO_WalletManager_createDeterministicWalletFromSpendKeyPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<ffi.Void> Function(
+                      ffi.Pointer<ffi.Void>,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Int,
+                      ffi.Uint64,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Uint64)>>(
+          'MONERO_WalletManager_createDeterministicWalletFromSpendKey');
+  late final _MONERO_WalletManager_createDeterministicWalletFromSpendKey =
+      _MONERO_WalletManager_createDeterministicWalletFromSpendKeyPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManager_createWalletFromDevice(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    int nettype,
+    ffi.Pointer<ffi.Char> deviceName,
+    int restoreHeight,
+    ffi.Pointer<ffi.Char> subaddressLookahead,
+    ffi.Pointer<ffi.Char> viewKeyString,
+    ffi.Pointer<ffi.Char> spendKeyString,
+    int kdf_rounds,
+  ) {
+    return _MONERO_WalletManager_createWalletFromDevice(
+      wm_ptr,
+      path,
+      password,
+      nettype,
+      deviceName,
+      restoreHeight,
+      subaddressLookahead,
+      viewKeyString,
+      spendKeyString,
+      kdf_rounds,
+    );
+  }
+
+  late final _MONERO_WalletManager_createWalletFromDevicePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64)>>('MONERO_WalletManager_createWalletFromDevice');
+  late final _MONERO_WalletManager_createWalletFromDevice =
+      _MONERO_WalletManager_createWalletFromDevicePtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              ffi.Pointer<ffi.Char>,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManager_createWalletFromPolyseed(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    int nettype,
+    ffi.Pointer<ffi.Char> mnemonic,
+    ffi.Pointer<ffi.Char> passphrase,
+    bool newWallet,
+    int restore_height,
+    int kdf_rounds,
+  ) {
+    return _MONERO_WalletManager_createWalletFromPolyseed(
+      wm_ptr,
+      path,
+      password,
+      nettype,
+      mnemonic,
+      passphrase,
+      newWallet,
+      restore_height,
+      kdf_rounds,
+    );
+  }
+
+  late final _MONERO_WalletManager_createWalletFromPolyseedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Uint64,
+              ffi.Uint64)>>('MONERO_WalletManager_createWalletFromPolyseed');
+  late final _MONERO_WalletManager_createWalletFromPolyseed =
+      _MONERO_WalletManager_createWalletFromPolyseedPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              bool,
+              int,
+              int)>();
+
+  bool MONERO_WalletManager_closeWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool store,
+  ) {
+    return _MONERO_WalletManager_closeWallet(
+      wm_ptr,
+      wallet_ptr,
+      store,
+    );
+  }
+
+  late final _MONERO_WalletManager_closeWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
+              ffi.Bool)>>('MONERO_WalletManager_closeWallet');
+  late final _MONERO_WalletManager_closeWallet =
+      _MONERO_WalletManager_closeWalletPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, bool)>();
+
+  bool MONERO_WalletManager_walletExists(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+  ) {
+    return _MONERO_WalletManager_walletExists(
+      wm_ptr,
+      path,
+    );
+  }
+
+  late final _MONERO_WalletManager_walletExistsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_WalletManager_walletExists');
+  late final _MONERO_WalletManager_walletExists =
+      _MONERO_WalletManager_walletExistsPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool MONERO_WalletManager_verifyWalletPassword(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> keys_file_name,
+    ffi.Pointer<ffi.Char> password,
+    bool no_spend_key,
+    int kdf_rounds,
+  ) {
+    return _MONERO_WalletManager_verifyWalletPassword(
+      wm_ptr,
+      keys_file_name,
+      password,
+      no_spend_key,
+      kdf_rounds,
+    );
+  }
+
+  late final _MONERO_WalletManager_verifyWalletPasswordPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Uint64)>>('MONERO_WalletManager_verifyWalletPassword');
+  late final _MONERO_WalletManager_verifyWalletPassword =
+      _MONERO_WalletManager_verifyWalletPasswordPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, bool, int)>();
+
+  bool MONERO_WalletManager_queryWalletDevice(
+    int device_type,
+    ffi.Pointer<ffi.Char> keys_file_name,
+    ffi.Pointer<ffi.Char> password,
+    int kdf_rounds,
+  ) {
+    return _MONERO_WalletManager_queryWalletDevice(
+      device_type,
+      keys_file_name,
+      password,
+      kdf_rounds,
+    );
+  }
+
+  late final _MONERO_WalletManager_queryWalletDevicePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64)>>('MONERO_WalletManager_queryWalletDevice');
+  late final _MONERO_WalletManager_queryWalletDevice =
+      _MONERO_WalletManager_queryWalletDevicePtr.asFunction<
+          bool Function(
+              int, ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_WalletManager_findWallets(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _MONERO_WalletManager_findWallets(
+      wm_ptr,
+      path,
+      separator,
+    );
+  }
+
+  late final _MONERO_WalletManager_findWalletsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_WalletManager_findWallets');
+  late final _MONERO_WalletManager_findWallets =
+      _MONERO_WalletManager_findWalletsPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_WalletManager_errorString(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_errorString(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_WalletManager_errorString');
+  late final _MONERO_WalletManager_errorString =
+      _MONERO_WalletManager_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_WalletManager_setDaemonAddress(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _MONERO_WalletManager_setDaemonAddress(
+      wm_ptr,
+      address,
+    );
+  }
+
+  late final _MONERO_WalletManager_setDaemonAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_WalletManager_setDaemonAddress');
+  late final _MONERO_WalletManager_setDaemonAddress =
+      _MONERO_WalletManager_setDaemonAddressPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int MONERO_WalletManager_blockchainHeight(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_blockchainHeight(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_blockchainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_WalletManager_blockchainHeight');
+  late final _MONERO_WalletManager_blockchainHeight =
+      _MONERO_WalletManager_blockchainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_WalletManager_blockchainTargetHeight(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_blockchainTargetHeight(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_blockchainTargetHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_WalletManager_blockchainTargetHeight');
+  late final _MONERO_WalletManager_blockchainTargetHeight =
+      _MONERO_WalletManager_blockchainTargetHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_WalletManager_networkDifficulty(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_networkDifficulty(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_networkDifficultyPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_WalletManager_networkDifficulty');
+  late final _MONERO_WalletManager_networkDifficulty =
+      _MONERO_WalletManager_networkDifficultyPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  double MONERO_WalletManager_miningHashRate(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_miningHashRate(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_miningHashRatePtr =
+      _lookup<ffi.NativeFunction<ffi.Double Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_WalletManager_miningHashRate');
+  late final _MONERO_WalletManager_miningHashRate =
+      _MONERO_WalletManager_miningHashRatePtr.asFunction<
+          double Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_WalletManager_blockTarget(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_blockTarget(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_blockTargetPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_WalletManager_blockTarget');
+  late final _MONERO_WalletManager_blockTarget =
+      _MONERO_WalletManager_blockTargetPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_WalletManager_isMining(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _MONERO_WalletManager_isMining(
+      wm_ptr,
+    );
+  }
+
+  late final _MONERO_WalletManager_isMiningPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_WalletManager_isMining');
+  late final _MONERO_WalletManager_isMining = _MONERO_WalletManager_isMiningPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_WalletManager_startMining(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+    int threads,
+    bool backgroundMining,
+    bool ignoreBattery,
+  ) {
+    return _MONERO_WalletManager_startMining(
+      wm_ptr,
+      address,
+      threads,
+      backgroundMining,
+      ignoreBattery,
+    );
+  }
+
+  late final _MONERO_WalletManager_startMiningPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint32,
+              ffi.Bool,
+              ffi.Bool)>>('MONERO_WalletManager_startMining');
+  late final _MONERO_WalletManager_startMining =
+      _MONERO_WalletManager_startMiningPtr.asFunction<
+          bool Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, int, bool, bool)>();
+
+  bool MONERO_WalletManager_stopMining(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _MONERO_WalletManager_stopMining(
+      wm_ptr,
+      address,
+    );
+  }
+
+  late final _MONERO_WalletManager_stopMiningPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_WalletManager_stopMining');
+  late final _MONERO_WalletManager_stopMining =
+      _MONERO_WalletManager_stopMiningPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> MONERO_WalletManager_resolveOpenAlias(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+    bool dnssec_valid,
+  ) {
+    return _MONERO_WalletManager_resolveOpenAlias(
+      wm_ptr,
+      address,
+      dnssec_valid,
+    );
+  }
+
+  late final _MONERO_WalletManager_resolveOpenAliasPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('MONERO_WalletManager_resolveOpenAlias');
+  late final _MONERO_WalletManager_resolveOpenAlias =
+      _MONERO_WalletManager_resolveOpenAliasPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  bool MONERO_WalletManager_setProxy(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _MONERO_WalletManager_setProxy(
+      wm_ptr,
+      address,
+    );
+  }
+
+  late final _MONERO_WalletManager_setProxyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('MONERO_WalletManager_setProxy');
+  late final _MONERO_WalletManager_setProxy =
+      _MONERO_WalletManager_setProxyPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_WalletManagerFactory_getWalletManager() {
+    return _MONERO_WalletManagerFactory_getWalletManager();
+  }
+
+  late final _MONERO_WalletManagerFactory_getWalletManagerPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function()>>(
+          'MONERO_WalletManagerFactory_getWalletManager');
+  late final _MONERO_WalletManagerFactory_getWalletManager =
+      _MONERO_WalletManagerFactory_getWalletManagerPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function()>();
+
+  void MONERO_WalletManagerFactory_setLogLevel(
+    int level,
+  ) {
+    return _MONERO_WalletManagerFactory_setLogLevel(
+      level,
+    );
+  }
+
+  late final _MONERO_WalletManagerFactory_setLogLevelPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int)>>(
+          'MONERO_WalletManagerFactory_setLogLevel');
+  late final _MONERO_WalletManagerFactory_setLogLevel =
+      _MONERO_WalletManagerFactory_setLogLevelPtr.asFunction<
+          void Function(int)>();
+
+  void MONERO_WalletManagerFactory_setLogCategories(
+    ffi.Pointer<ffi.Char> categories,
+  ) {
+    return _MONERO_WalletManagerFactory_setLogCategories(
+      categories,
+    );
+  }
+
+  late final _MONERO_WalletManagerFactory_setLogCategoriesPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char>)>>(
+          'MONERO_WalletManagerFactory_setLogCategories');
+  late final _MONERO_WalletManagerFactory_setLogCategories =
+      _MONERO_WalletManagerFactory_setLogCategoriesPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Char>)>();
+
+  void MONERO_DEBUG_test0() {
+    return _MONERO_DEBUG_test0();
+  }
+
+  late final _MONERO_DEBUG_test0Ptr =
+      _lookup<ffi.NativeFunction<ffi.Void Function()>>('MONERO_DEBUG_test0');
+  late final _MONERO_DEBUG_test0 =
+      _MONERO_DEBUG_test0Ptr.asFunction<void Function()>();
+
+  bool MONERO_DEBUG_test1(
+    bool x,
+  ) {
+    return _MONERO_DEBUG_test1(
+      x,
+    );
+  }
+
+  late final _MONERO_DEBUG_test1Ptr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Bool)>>(
+          'MONERO_DEBUG_test1');
+  late final _MONERO_DEBUG_test1 =
+      _MONERO_DEBUG_test1Ptr.asFunction<bool Function(bool)>();
+
+  int MONERO_DEBUG_test2(
+    int x,
+  ) {
+    return _MONERO_DEBUG_test2(
+      x,
+    );
+  }
+
+  late final _MONERO_DEBUG_test2Ptr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Int)>>(
+          'MONERO_DEBUG_test2');
+  late final _MONERO_DEBUG_test2 =
+      _MONERO_DEBUG_test2Ptr.asFunction<int Function(int)>();
+
+  int MONERO_DEBUG_test3(
+    int x,
+  ) {
+    return _MONERO_DEBUG_test3(
+      x,
+    );
+  }
+
+  late final _MONERO_DEBUG_test3Ptr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Uint64)>>(
+          'MONERO_DEBUG_test3');
+  late final _MONERO_DEBUG_test3 =
+      _MONERO_DEBUG_test3Ptr.asFunction<int Function(int)>();
+
+  ffi.Pointer<ffi.Void> MONERO_DEBUG_test4(
+    int x,
+  ) {
+    return _MONERO_DEBUG_test4(
+      x,
+    );
+  }
+
+  late final _MONERO_DEBUG_test4Ptr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Uint64)>>(
+          'MONERO_DEBUG_test4');
+  late final _MONERO_DEBUG_test4 =
+      _MONERO_DEBUG_test4Ptr.asFunction<ffi.Pointer<ffi.Void> Function(int)>();
+
+  ffi.Pointer<ffi.Char> MONERO_DEBUG_test5() {
+    return _MONERO_DEBUG_test5();
+  }
+
+  late final _MONERO_DEBUG_test5Ptr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
+          'MONERO_DEBUG_test5');
+  late final _MONERO_DEBUG_test5 =
+      _MONERO_DEBUG_test5Ptr.asFunction<ffi.Pointer<ffi.Char> Function()>();
+
+  ffi.Pointer<ffi.Char> MONERO_DEBUG_test5_std() {
+    return _MONERO_DEBUG_test5_std();
+  }
+
+  late final _MONERO_DEBUG_test5_stdPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
+          'MONERO_DEBUG_test5_std');
+  late final _MONERO_DEBUG_test5_std =
+      _MONERO_DEBUG_test5_stdPtr.asFunction<ffi.Pointer<ffi.Char> Function()>();
+
+  bool MONERO_DEBUG_isPointerNull(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_DEBUG_isPointerNull(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_DEBUG_isPointerNullPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_DEBUG_isPointerNull');
+  late final _MONERO_DEBUG_isPointerNull = _MONERO_DEBUG_isPointerNullPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> MONERO_cw_getWalletListener(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _MONERO_cw_getWalletListener(
+      wallet_ptr,
+    );
+  }
+
+  late final _MONERO_cw_getWalletListenerPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('MONERO_cw_getWalletListener');
+  late final _MONERO_cw_getWalletListener = _MONERO_cw_getWalletListenerPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_cw_WalletListener_resetNeedToRefresh(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _MONERO_cw_WalletListener_resetNeedToRefresh(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _MONERO_cw_WalletListener_resetNeedToRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_cw_WalletListener_resetNeedToRefresh');
+  late final _MONERO_cw_WalletListener_resetNeedToRefresh =
+      _MONERO_cw_WalletListener_resetNeedToRefreshPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_cw_WalletListener_isNeedToRefresh(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _MONERO_cw_WalletListener_isNeedToRefresh(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _MONERO_cw_WalletListener_isNeedToRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_cw_WalletListener_isNeedToRefresh');
+  late final _MONERO_cw_WalletListener_isNeedToRefresh =
+      _MONERO_cw_WalletListener_isNeedToRefreshPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool MONERO_cw_WalletListener_isNewTransactionExist(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _MONERO_cw_WalletListener_isNewTransactionExist(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _MONERO_cw_WalletListener_isNewTransactionExistPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_cw_WalletListener_isNewTransactionExist');
+  late final _MONERO_cw_WalletListener_isNewTransactionExist =
+      _MONERO_cw_WalletListener_isNewTransactionExistPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_cw_WalletListener_resetIsNewTransactionExist(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _MONERO_cw_WalletListener_resetIsNewTransactionExist(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _MONERO_cw_WalletListener_resetIsNewTransactionExistPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_cw_WalletListener_resetIsNewTransactionExist');
+  late final _MONERO_cw_WalletListener_resetIsNewTransactionExist =
+      _MONERO_cw_WalletListener_resetIsNewTransactionExistPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  int MONERO_cw_WalletListener_height(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _MONERO_cw_WalletListener_height(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _MONERO_cw_WalletListener_heightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_cw_WalletListener_height');
+  late final _MONERO_cw_WalletListener_height =
+      _MONERO_cw_WalletListener_heightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void MONERO_free(
+    ffi.Pointer<ffi.Void> ptr,
+  ) {
+    return _MONERO_free(
+      ptr,
+    );
+  }
+
+  late final _MONERO_freePtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'MONERO_free');
+  late final _MONERO_free =
+      _MONERO_freePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+}
diff --git a/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart b/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart
new file mode 100644
index 0000000..527ab17
--- /dev/null
+++ b/impls/monero.dart/lib/src/generated_bindings_wownero.g.dart
@@ -0,0 +1,4980 @@
+// AUTO GENERATED FILE, DO NOT EDIT.
+//
+// Generated by `package:ffigen`.
+// ignore_for_file: type=lint
+import 'dart:ffi' as ffi;
+
+/// monero_c wownero bindings
+class WowneroC {
+  /// Holds the symbol lookup function.
+  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
+      _lookup;
+
+  /// The symbols are looked up in [dynamicLibrary].
+  WowneroC(ffi.DynamicLibrary dynamicLibrary) : _lookup = dynamicLibrary.lookup;
+
+  /// The symbols are looked up with [lookup].
+  WowneroC.fromLookup(
+      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
+          lookup)
+      : _lookup = lookup;
+
+  int WOWNERO_PendingTransaction_status(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_status(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_statusPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_PendingTransaction_status');
+  late final _WOWNERO_PendingTransaction_status =
+      _WOWNERO_PendingTransaction_statusPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_errorString(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_errorString(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_errorStringPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_PendingTransaction_errorString');
+  late final _WOWNERO_PendingTransaction_errorString =
+      _WOWNERO_PendingTransaction_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_PendingTransaction_commit(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> filename,
+    bool overwrite,
+  ) {
+    return _WOWNERO_PendingTransaction_commit(
+      pendingTx_ptr,
+      filename,
+      overwrite,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_commitPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('WOWNERO_PendingTransaction_commit');
+  late final _WOWNERO_PendingTransaction_commit =
+      _WOWNERO_PendingTransaction_commitPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  int WOWNERO_PendingTransaction_amount(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_amount(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_amountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_PendingTransaction_amount');
+  late final _WOWNERO_PendingTransaction_amount =
+      _WOWNERO_PendingTransaction_amountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_PendingTransaction_dust(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_dust(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_dustPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_PendingTransaction_dust');
+  late final _WOWNERO_PendingTransaction_dust =
+      _WOWNERO_PendingTransaction_dustPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_PendingTransaction_fee(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_fee(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_feePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_PendingTransaction_fee');
+  late final _WOWNERO_PendingTransaction_fee =
+      _WOWNERO_PendingTransaction_feePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_txid(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_PendingTransaction_txid(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_txidPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_PendingTransaction_txid');
+  late final _WOWNERO_PendingTransaction_txid =
+      _WOWNERO_PendingTransaction_txidPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_PendingTransaction_txCount(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_txCount(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_txCountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_PendingTransaction_txCount');
+  late final _WOWNERO_PendingTransaction_txCount =
+      _WOWNERO_PendingTransaction_txCountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_subaddrAccount(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_PendingTransaction_subaddrAccount(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_subaddrAccountPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_PendingTransaction_subaddrAccount');
+  late final _WOWNERO_PendingTransaction_subaddrAccount =
+      _WOWNERO_PendingTransaction_subaddrAccountPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_subaddrIndices(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_PendingTransaction_subaddrIndices(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_subaddrIndicesPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_PendingTransaction_subaddrIndices');
+  late final _WOWNERO_PendingTransaction_subaddrIndices =
+      _WOWNERO_PendingTransaction_subaddrIndicesPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_multisigSignData(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_multisigSignData(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_multisigSignDataPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_PendingTransaction_multisigSignData');
+  late final _WOWNERO_PendingTransaction_multisigSignData =
+      _WOWNERO_PendingTransaction_multisigSignDataPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_PendingTransaction_signMultisigTx(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+  ) {
+    return _WOWNERO_PendingTransaction_signMultisigTx(
+      pendingTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_signMultisigTxPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_PendingTransaction_signMultisigTx');
+  late final _WOWNERO_PendingTransaction_signMultisigTx =
+      _WOWNERO_PendingTransaction_signMultisigTxPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_signersKeys(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_PendingTransaction_signersKeys(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_signersKeysPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_PendingTransaction_signersKeys');
+  late final _WOWNERO_PendingTransaction_signersKeys =
+      _WOWNERO_PendingTransaction_signersKeysPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_PendingTransaction_hex(
+    ffi.Pointer<ffi.Void> pendingTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_PendingTransaction_hex(
+      pendingTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_PendingTransaction_hexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_PendingTransaction_hex');
+  late final _WOWNERO_PendingTransaction_hex =
+      _WOWNERO_PendingTransaction_hexPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_UnsignedTransaction_status(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _WOWNERO_UnsignedTransaction_status(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_statusPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_UnsignedTransaction_status');
+  late final _WOWNERO_UnsignedTransaction_status =
+      _WOWNERO_UnsignedTransaction_statusPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_errorString(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _WOWNERO_UnsignedTransaction_errorString(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_errorStringPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_UnsignedTransaction_errorString');
+  late final _WOWNERO_UnsignedTransaction_errorString =
+      _WOWNERO_UnsignedTransaction_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_amount(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_UnsignedTransaction_amount(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_amountPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_amount');
+  late final _WOWNERO_UnsignedTransaction_amount =
+      _WOWNERO_UnsignedTransaction_amountPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_fee(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_UnsignedTransaction_fee(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_feePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_fee');
+  late final _WOWNERO_UnsignedTransaction_fee =
+      _WOWNERO_UnsignedTransaction_feePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_mixin(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_UnsignedTransaction_mixin(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_mixinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_mixin');
+  late final _WOWNERO_UnsignedTransaction_mixin =
+      _WOWNERO_UnsignedTransaction_mixinPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_confirmationMessage(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _WOWNERO_UnsignedTransaction_confirmationMessage(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_confirmationMessagePtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_UnsignedTransaction_confirmationMessage');
+  late final _WOWNERO_UnsignedTransaction_confirmationMessage =
+      _WOWNERO_UnsignedTransaction_confirmationMessagePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_paymentId(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_UnsignedTransaction_paymentId(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_paymentIdPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_paymentId');
+  late final _WOWNERO_UnsignedTransaction_paymentId =
+      _WOWNERO_UnsignedTransaction_paymentIdPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_UnsignedTransaction_recipientAddress(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_UnsignedTransaction_recipientAddress(
+      unsignedTx_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_recipientAddressPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_UnsignedTransaction_recipientAddress');
+  late final _WOWNERO_UnsignedTransaction_recipientAddress =
+      _WOWNERO_UnsignedTransaction_recipientAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_UnsignedTransaction_minMixinCount(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _WOWNERO_UnsignedTransaction_minMixinCount(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_minMixinCountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_UnsignedTransaction_minMixinCount');
+  late final _WOWNERO_UnsignedTransaction_minMixinCount =
+      _WOWNERO_UnsignedTransaction_minMixinCountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_UnsignedTransaction_txCount(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+  ) {
+    return _WOWNERO_UnsignedTransaction_txCount(
+      unsignedTx_ptr,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_txCountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_UnsignedTransaction_txCount');
+  late final _WOWNERO_UnsignedTransaction_txCount =
+      _WOWNERO_UnsignedTransaction_txCountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_UnsignedTransaction_sign(
+    ffi.Pointer<ffi.Void> unsignedTx_ptr,
+    ffi.Pointer<ffi.Char> signedFileName,
+  ) {
+    return _WOWNERO_UnsignedTransaction_sign(
+      unsignedTx_ptr,
+      signedFileName,
+    );
+  }
+
+  late final _WOWNERO_UnsignedTransaction_signPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_UnsignedTransaction_sign');
+  late final _WOWNERO_UnsignedTransaction_sign =
+      _WOWNERO_UnsignedTransaction_signPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_TransactionInfo_direction(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_direction(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_directionPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_direction');
+  late final _WOWNERO_TransactionInfo_direction =
+      _WOWNERO_TransactionInfo_directionPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_TransactionInfo_isPending(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_isPending(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_isPendingPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_isPending');
+  late final _WOWNERO_TransactionInfo_isPending =
+      _WOWNERO_TransactionInfo_isPendingPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_TransactionInfo_isFailed(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_isFailed(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_isFailedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_isFailed');
+  late final _WOWNERO_TransactionInfo_isFailed =
+      _WOWNERO_TransactionInfo_isFailedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_TransactionInfo_isCoinbase(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_isCoinbase(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_isCoinbasePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_isCoinbase');
+  late final _WOWNERO_TransactionInfo_isCoinbase =
+      _WOWNERO_TransactionInfo_isCoinbasePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_amount(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_amount(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_amountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_amount');
+  late final _WOWNERO_TransactionInfo_amount =
+      _WOWNERO_TransactionInfo_amountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_fee(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_fee(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_feePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_fee');
+  late final _WOWNERO_TransactionInfo_fee = _WOWNERO_TransactionInfo_feePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_blockHeight(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_blockHeight(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_blockHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_blockHeight');
+  late final _WOWNERO_TransactionInfo_blockHeight =
+      _WOWNERO_TransactionInfo_blockHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_description(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_description(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_descriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_description');
+  late final _WOWNERO_TransactionInfo_description =
+      _WOWNERO_TransactionInfo_descriptionPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_subaddrIndex(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_TransactionInfo_subaddrIndex(
+      txInfo_ptr,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_subaddrIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_TransactionInfo_subaddrIndex');
+  late final _WOWNERO_TransactionInfo_subaddrIndex =
+      _WOWNERO_TransactionInfo_subaddrIndexPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_TransactionInfo_subaddrAccount(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_subaddrAccount(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_subaddrAccountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_subaddrAccount');
+  late final _WOWNERO_TransactionInfo_subaddrAccount =
+      _WOWNERO_TransactionInfo_subaddrAccountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_label(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_label(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_labelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_label');
+  late final _WOWNERO_TransactionInfo_label = _WOWNERO_TransactionInfo_labelPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_confirmations(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_confirmations(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_confirmationsPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_confirmations');
+  late final _WOWNERO_TransactionInfo_confirmations =
+      _WOWNERO_TransactionInfo_confirmationsPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_unlockTime(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_unlockTime(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_unlockTimePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_unlockTime');
+  late final _WOWNERO_TransactionInfo_unlockTime =
+      _WOWNERO_TransactionInfo_unlockTimePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_hash(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_hash(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_hashPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_hash');
+  late final _WOWNERO_TransactionInfo_hash = _WOWNERO_TransactionInfo_hashPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_timestamp(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_timestamp(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_timestampPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_timestamp');
+  late final _WOWNERO_TransactionInfo_timestamp =
+      _WOWNERO_TransactionInfo_timestampPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_paymentId(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_paymentId(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_paymentIdPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_TransactionInfo_paymentId');
+  late final _WOWNERO_TransactionInfo_paymentId =
+      _WOWNERO_TransactionInfo_paymentIdPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_transfers_count(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+  ) {
+    return _WOWNERO_TransactionInfo_transfers_count(
+      txInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_transfers_countPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionInfo_transfers_count');
+  late final _WOWNERO_TransactionInfo_transfers_count =
+      _WOWNERO_TransactionInfo_transfers_countPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_TransactionInfo_transfers_amount(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+    int index,
+  ) {
+    return _WOWNERO_TransactionInfo_transfers_amount(
+      txInfo_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_transfers_amountPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'WOWNERO_TransactionInfo_transfers_amount');
+  late final _WOWNERO_TransactionInfo_transfers_amount =
+      _WOWNERO_TransactionInfo_transfers_amountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_TransactionInfo_transfers_address(
+    ffi.Pointer<ffi.Void> txInfo_ptr,
+    int address,
+  ) {
+    return _WOWNERO_TransactionInfo_transfers_address(
+      txInfo_ptr,
+      address,
+    );
+  }
+
+  late final _WOWNERO_TransactionInfo_transfers_addressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('WOWNERO_TransactionInfo_transfers_address');
+  late final _WOWNERO_TransactionInfo_transfers_address =
+      _WOWNERO_TransactionInfo_transfers_addressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_TransactionHistory_count(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+  ) {
+    return _WOWNERO_TransactionHistory_count(
+      txHistory_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionHistory_countPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionHistory_count');
+  late final _WOWNERO_TransactionHistory_count =
+      _WOWNERO_TransactionHistory_countPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_TransactionHistory_transaction(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+    int index,
+  ) {
+    return _WOWNERO_TransactionHistory_transaction(
+      txHistory_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_TransactionHistory_transactionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('WOWNERO_TransactionHistory_transaction');
+  late final _WOWNERO_TransactionHistory_transaction =
+      _WOWNERO_TransactionHistory_transactionPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_TransactionHistory_transactionById(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+    ffi.Pointer<ffi.Char> id,
+  ) {
+    return _WOWNERO_TransactionHistory_transactionById(
+      txHistory_ptr,
+      id,
+    );
+  }
+
+  late final _WOWNERO_TransactionHistory_transactionByIdPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Void> Function(
+                  ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_TransactionHistory_transactionById');
+  late final _WOWNERO_TransactionHistory_transactionById =
+      _WOWNERO_TransactionHistory_transactionByIdPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_TransactionHistory_refresh(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+  ) {
+    return _WOWNERO_TransactionHistory_refresh(
+      txHistory_ptr,
+    );
+  }
+
+  late final _WOWNERO_TransactionHistory_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_TransactionHistory_refresh');
+  late final _WOWNERO_TransactionHistory_refresh =
+      _WOWNERO_TransactionHistory_refreshPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_TransactionHistory_setTxNote(
+    ffi.Pointer<ffi.Void> txHistory_ptr,
+    ffi.Pointer<ffi.Char> txid,
+    ffi.Pointer<ffi.Char> note,
+  ) {
+    return _WOWNERO_TransactionHistory_setTxNote(
+      txHistory_ptr,
+      txid,
+      note,
+    );
+  }
+
+  late final _WOWNERO_TransactionHistory_setTxNotePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_TransactionHistory_setTxNote');
+  late final _WOWNERO_TransactionHistory_setTxNote =
+      _WOWNERO_TransactionHistory_setTxNotePtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_extra(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _WOWNERO_AddressBookRow_extra(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBookRow_extraPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_extra');
+  late final _WOWNERO_AddressBookRow_extra = _WOWNERO_AddressBookRow_extraPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_getAddress(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _WOWNERO_AddressBookRow_getAddress(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBookRow_getAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_getAddress');
+  late final _WOWNERO_AddressBookRow_getAddress =
+      _WOWNERO_AddressBookRow_getAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_getDescription(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _WOWNERO_AddressBookRow_getDescription(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBookRow_getDescriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_getDescription');
+  late final _WOWNERO_AddressBookRow_getDescription =
+      _WOWNERO_AddressBookRow_getDescriptionPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_AddressBookRow_getPaymentId(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _WOWNERO_AddressBookRow_getPaymentId(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBookRow_getPaymentIdPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBookRow_getPaymentId');
+  late final _WOWNERO_AddressBookRow_getPaymentId =
+      _WOWNERO_AddressBookRow_getPaymentIdPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_AddressBookRow_getRowId(
+    ffi.Pointer<ffi.Void> addressBookRow_ptr,
+  ) {
+    return _WOWNERO_AddressBookRow_getRowId(
+      addressBookRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBookRow_getRowIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_AddressBookRow_getRowId');
+  late final _WOWNERO_AddressBookRow_getRowId =
+      _WOWNERO_AddressBookRow_getRowIdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_AddressBook_getAll_size(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _WOWNERO_AddressBook_getAll_size(
+      addressBook_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_AddressBook_getAll_size');
+  late final _WOWNERO_AddressBook_getAll_size =
+      _WOWNERO_AddressBook_getAll_sizePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_AddressBook_getAll_byIndex(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    int index,
+  ) {
+    return _WOWNERO_AddressBook_getAll_byIndex(
+      addressBook_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('WOWNERO_AddressBook_getAll_byIndex');
+  late final _WOWNERO_AddressBook_getAll_byIndex =
+      _WOWNERO_AddressBook_getAll_byIndexPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool WOWNERO_AddressBook_addRow(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    ffi.Pointer<ffi.Char> dst_addr,
+    ffi.Pointer<ffi.Char> payment_id,
+    ffi.Pointer<ffi.Char> description,
+  ) {
+    return _WOWNERO_AddressBook_addRow(
+      addressBook_ptr,
+      dst_addr,
+      payment_id,
+      description,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_addRowPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_AddressBook_addRow');
+  late final _WOWNERO_AddressBook_addRow =
+      _WOWNERO_AddressBook_addRowPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_AddressBook_deleteRow(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    int rowId,
+  ) {
+    return _WOWNERO_AddressBook_deleteRow(
+      addressBook_ptr,
+      rowId,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_deleteRowPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Size)>>(
+      'WOWNERO_AddressBook_deleteRow');
+  late final _WOWNERO_AddressBook_deleteRow = _WOWNERO_AddressBook_deleteRowPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool WOWNERO_AddressBook_setDescription(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    int rowId,
+    ffi.Pointer<ffi.Char> description,
+  ) {
+    return _WOWNERO_AddressBook_setDescription(
+      addressBook_ptr,
+      rowId,
+      description,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_setDescriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Size,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_AddressBook_setDescription');
+  late final _WOWNERO_AddressBook_setDescription =
+      _WOWNERO_AddressBook_setDescriptionPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_AddressBook_refresh(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _WOWNERO_AddressBook_refresh(
+      addressBook_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_AddressBook_refresh');
+  late final _WOWNERO_AddressBook_refresh = _WOWNERO_AddressBook_refreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_AddressBook_errorString(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _WOWNERO_AddressBook_errorString(
+      addressBook_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_AddressBook_errorString');
+  late final _WOWNERO_AddressBook_errorString =
+      _WOWNERO_AddressBook_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_AddressBook_errorCode(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+  ) {
+    return _WOWNERO_AddressBook_errorCode(
+      addressBook_ptr,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_errorCodePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_AddressBook_errorCode');
+  late final _WOWNERO_AddressBook_errorCode = _WOWNERO_AddressBook_errorCodePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_AddressBook_lookupPaymentID(
+    ffi.Pointer<ffi.Void> addressBook_ptr,
+    ffi.Pointer<ffi.Char> payment_id,
+  ) {
+    return _WOWNERO_AddressBook_lookupPaymentID(
+      addressBook_ptr,
+      payment_id,
+    );
+  }
+
+  late final _WOWNERO_AddressBook_lookupPaymentIDPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Int Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_AddressBook_lookupPaymentID');
+  late final _WOWNERO_AddressBook_lookupPaymentID =
+      _WOWNERO_AddressBook_lookupPaymentIDPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_CoinsInfo_blockHeight(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_blockHeight(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_blockHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_blockHeight');
+  late final _WOWNERO_CoinsInfo_blockHeight = _WOWNERO_CoinsInfo_blockHeightPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_hash(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_hash(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_hashPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_hash');
+  late final _WOWNERO_CoinsInfo_hash = _WOWNERO_CoinsInfo_hashPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_internalOutputIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_internalOutputIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_internalOutputIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_internalOutputIndex');
+  late final _WOWNERO_CoinsInfo_internalOutputIndex =
+      _WOWNERO_CoinsInfo_internalOutputIndexPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_globalOutputIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_globalOutputIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_globalOutputIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_globalOutputIndex');
+  late final _WOWNERO_CoinsInfo_globalOutputIndex =
+      _WOWNERO_CoinsInfo_globalOutputIndexPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_CoinsInfo_spent(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_spent(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_spentPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_spent');
+  late final _WOWNERO_CoinsInfo_spent = _WOWNERO_CoinsInfo_spentPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_CoinsInfo_frozen(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_frozen(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_frozenPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_frozen');
+  late final _WOWNERO_CoinsInfo_frozen = _WOWNERO_CoinsInfo_frozenPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_spentHeight(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_spentHeight(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_spentHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_spentHeight');
+  late final _WOWNERO_CoinsInfo_spentHeight = _WOWNERO_CoinsInfo_spentHeightPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_amount(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_amount(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_amountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_amount');
+  late final _WOWNERO_CoinsInfo_amount = _WOWNERO_CoinsInfo_amountPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_CoinsInfo_rct(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_rct(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_rctPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_rct');
+  late final _WOWNERO_CoinsInfo_rct = _WOWNERO_CoinsInfo_rctPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_CoinsInfo_keyImageKnown(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_keyImageKnown(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_keyImageKnownPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_keyImageKnown');
+  late final _WOWNERO_CoinsInfo_keyImageKnown =
+      _WOWNERO_CoinsInfo_keyImageKnownPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_pkIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_pkIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_pkIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_pkIndex');
+  late final _WOWNERO_CoinsInfo_pkIndex = _WOWNERO_CoinsInfo_pkIndexPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_subaddrIndex(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_subaddrIndex(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_subaddrIndexPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_subaddrIndex');
+  late final _WOWNERO_CoinsInfo_subaddrIndex =
+      _WOWNERO_CoinsInfo_subaddrIndexPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_subaddrAccount(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_subaddrAccount(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_subaddrAccountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_subaddrAccount');
+  late final _WOWNERO_CoinsInfo_subaddrAccount =
+      _WOWNERO_CoinsInfo_subaddrAccountPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_address(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_address(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_addressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_address');
+  late final _WOWNERO_CoinsInfo_address = _WOWNERO_CoinsInfo_addressPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_addressLabel(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_addressLabel(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_addressLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_addressLabel');
+  late final _WOWNERO_CoinsInfo_addressLabel =
+      _WOWNERO_CoinsInfo_addressLabelPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_keyImage(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_keyImage(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_keyImagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_keyImage');
+  late final _WOWNERO_CoinsInfo_keyImage = _WOWNERO_CoinsInfo_keyImagePtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_CoinsInfo_unlockTime(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_unlockTime(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_unlockTimePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_unlockTime');
+  late final _WOWNERO_CoinsInfo_unlockTime = _WOWNERO_CoinsInfo_unlockTimePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_CoinsInfo_unlocked(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_unlocked(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_unlockedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_unlocked');
+  late final _WOWNERO_CoinsInfo_unlocked = _WOWNERO_CoinsInfo_unlockedPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_pubKey(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_pubKey(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_pubKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_pubKey');
+  late final _WOWNERO_CoinsInfo_pubKey = _WOWNERO_CoinsInfo_pubKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_CoinsInfo_coinbase(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_coinbase(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_coinbasePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_CoinsInfo_coinbase');
+  late final _WOWNERO_CoinsInfo_coinbase = _WOWNERO_CoinsInfo_coinbasePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_CoinsInfo_description(
+    ffi.Pointer<ffi.Void> coinsInfo_ptr,
+  ) {
+    return _WOWNERO_CoinsInfo_description(
+      coinsInfo_ptr,
+    );
+  }
+
+  late final _WOWNERO_CoinsInfo_descriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_CoinsInfo_description');
+  late final _WOWNERO_CoinsInfo_description = _WOWNERO_CoinsInfo_descriptionPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Coins_count(
+    ffi.Pointer<ffi.Void> coins_ptr,
+  ) {
+    return _WOWNERO_Coins_count(
+      coins_ptr,
+    );
+  }
+
+  late final _WOWNERO_Coins_countPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Coins_count');
+  late final _WOWNERO_Coins_count =
+      _WOWNERO_Coins_countPtr.asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Coins_coin(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _WOWNERO_Coins_coin(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_Coins_coinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Int)>>('WOWNERO_Coins_coin');
+  late final _WOWNERO_Coins_coin = _WOWNERO_Coins_coinPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_Coins_getAll_size(
+    ffi.Pointer<ffi.Void> coins_ptr,
+  ) {
+    return _WOWNERO_Coins_getAll_size(
+      coins_ptr,
+    );
+  }
+
+  late final _WOWNERO_Coins_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Coins_getAll_size');
+  late final _WOWNERO_Coins_getAll_size = _WOWNERO_Coins_getAll_sizePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Coins_getAll_byIndex(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _WOWNERO_Coins_getAll_byIndex(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_Coins_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Int)>>('WOWNERO_Coins_getAll_byIndex');
+  late final _WOWNERO_Coins_getAll_byIndex = _WOWNERO_Coins_getAll_byIndexPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_Coins_refresh(
+    ffi.Pointer<ffi.Void> coins_ptr,
+  ) {
+    return _WOWNERO_Coins_refresh(
+      coins_ptr,
+    );
+  }
+
+  late final _WOWNERO_Coins_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Coins_refresh');
+  late final _WOWNERO_Coins_refresh = _WOWNERO_Coins_refreshPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Coins_setFrozenByPublicKey(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    ffi.Pointer<ffi.Char> public_key,
+  ) {
+    return _WOWNERO_Coins_setFrozenByPublicKey(
+      coins_ptr,
+      public_key,
+    );
+  }
+
+  late final _WOWNERO_Coins_setFrozenByPublicKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Coins_setFrozenByPublicKey');
+  late final _WOWNERO_Coins_setFrozenByPublicKey =
+      _WOWNERO_Coins_setFrozenByPublicKeyPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_Coins_setFrozen(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _WOWNERO_Coins_setFrozen(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_Coins_setFrozenPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'WOWNERO_Coins_setFrozen');
+  late final _WOWNERO_Coins_setFrozen = _WOWNERO_Coins_setFrozenPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_Coins_thaw(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int index,
+  ) {
+    return _WOWNERO_Coins_thaw(
+      coins_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_Coins_thawPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'WOWNERO_Coins_thaw');
+  late final _WOWNERO_Coins_thaw = _WOWNERO_Coins_thawPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_Coins_thawByPublicKey(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    ffi.Pointer<ffi.Char> public_key,
+  ) {
+    return _WOWNERO_Coins_thawByPublicKey(
+      coins_ptr,
+      public_key,
+    );
+  }
+
+  late final _WOWNERO_Coins_thawByPublicKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Coins_thawByPublicKey');
+  late final _WOWNERO_Coins_thawByPublicKey =
+      _WOWNERO_Coins_thawByPublicKeyPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Coins_isTransferUnlocked(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    int unlockTime,
+    int blockHeight,
+  ) {
+    return _WOWNERO_Coins_isTransferUnlocked(
+      coins_ptr,
+      unlockTime,
+      blockHeight,
+    );
+  }
+
+  late final _WOWNERO_Coins_isTransferUnlockedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
+              ffi.Uint64)>>('WOWNERO_Coins_isTransferUnlocked');
+  late final _WOWNERO_Coins_isTransferUnlocked =
+      _WOWNERO_Coins_isTransferUnlockedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  void WOWNERO_Coins_setDescription(
+    ffi.Pointer<ffi.Void> coins_ptr,
+    ffi.Pointer<ffi.Char> public_key,
+    ffi.Pointer<ffi.Char> description,
+  ) {
+    return _WOWNERO_Coins_setDescription(
+      coins_ptr,
+      public_key,
+      description,
+    );
+  }
+
+  late final _WOWNERO_Coins_setDescriptionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Coins_setDescription');
+  late final _WOWNERO_Coins_setDescription =
+      _WOWNERO_Coins_setDescriptionPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressRow_extra(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressRow_extra(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressRow_extraPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressRow_extra');
+  late final _WOWNERO_SubaddressRow_extra = _WOWNERO_SubaddressRow_extraPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressRow_getAddress(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressRow_getAddress(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressRow_getAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressRow_getAddress');
+  late final _WOWNERO_SubaddressRow_getAddress =
+      _WOWNERO_SubaddressRow_getAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressRow_getLabel(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressRow_getLabel(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressRow_getLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressRow_getLabel');
+  late final _WOWNERO_SubaddressRow_getLabel =
+      _WOWNERO_SubaddressRow_getLabelPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_SubaddressRow_getRowId(
+    ffi.Pointer<ffi.Void> subaddressRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressRow_getRowId(
+      subaddressRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressRow_getRowIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_SubaddressRow_getRowId');
+  late final _WOWNERO_SubaddressRow_getRowId =
+      _WOWNERO_SubaddressRow_getRowIdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Subaddress_getAll_size(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+  ) {
+    return _WOWNERO_Subaddress_getAll_size(
+      subaddress_ptr,
+    );
+  }
+
+  late final _WOWNERO_Subaddress_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Subaddress_getAll_size');
+  late final _WOWNERO_Subaddress_getAll_size =
+      _WOWNERO_Subaddress_getAll_sizePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Subaddress_getAll_byIndex(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int index,
+  ) {
+    return _WOWNERO_Subaddress_getAll_byIndex(
+      subaddress_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_Subaddress_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('WOWNERO_Subaddress_getAll_byIndex');
+  late final _WOWNERO_Subaddress_getAll_byIndex =
+      _WOWNERO_Subaddress_getAll_byIndexPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_Subaddress_addRow(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int accountIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_Subaddress_addRow(
+      subaddress_ptr,
+      accountIndex,
+      label,
+    );
+  }
+
+  late final _WOWNERO_Subaddress_addRowPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Subaddress_addRow');
+  late final _WOWNERO_Subaddress_addRow =
+      _WOWNERO_Subaddress_addRowPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_Subaddress_setLabel(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int accountIndex,
+    int addressIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_Subaddress_setLabel(
+      subaddress_ptr,
+      accountIndex,
+      addressIndex,
+      label,
+    );
+  }
+
+  late final _WOWNERO_Subaddress_setLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Subaddress_setLabel');
+  late final _WOWNERO_Subaddress_setLabel =
+      _WOWNERO_Subaddress_setLabelPtr.asFunction<
+          void Function(
+              ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_Subaddress_refresh(
+    ffi.Pointer<ffi.Void> subaddress_ptr,
+    int accountIndex,
+  ) {
+    return _WOWNERO_Subaddress_refresh(
+      subaddress_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _WOWNERO_Subaddress_refreshPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('WOWNERO_Subaddress_refresh');
+  late final _WOWNERO_Subaddress_refresh = _WOWNERO_Subaddress_refreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_extra(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccountRow_extra(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccountRow_extraPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressAccountRow_extra');
+  late final _WOWNERO_SubaddressAccountRow_extra =
+      _WOWNERO_SubaddressAccountRow_extraPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getAddress(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccountRow_getAddress(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccountRow_getAddressPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_SubaddressAccountRow_getAddress');
+  late final _WOWNERO_SubaddressAccountRow_getAddress =
+      _WOWNERO_SubaddressAccountRow_getAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getLabel(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccountRow_getLabel(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccountRow_getLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_SubaddressAccountRow_getLabel');
+  late final _WOWNERO_SubaddressAccountRow_getLabel =
+      _WOWNERO_SubaddressAccountRow_getLabelPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getBalance(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccountRow_getBalance(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccountRow_getBalancePtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_SubaddressAccountRow_getBalance');
+  late final _WOWNERO_SubaddressAccountRow_getBalance =
+      _WOWNERO_SubaddressAccountRow_getBalancePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_SubaddressAccountRow_getUnlockedBalance(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccountRow_getUnlockedBalance(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccountRow_getUnlockedBalancePtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+  late final _WOWNERO_SubaddressAccountRow_getUnlockedBalance =
+      _WOWNERO_SubaddressAccountRow_getUnlockedBalancePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_SubaddressAccountRow_getRowId(
+    ffi.Pointer<ffi.Void> subaddressAccountRow_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccountRow_getRowId(
+      subaddressAccountRow_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccountRow_getRowIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_SubaddressAccountRow_getRowId');
+  late final _WOWNERO_SubaddressAccountRow_getRowId =
+      _WOWNERO_SubaddressAccountRow_getRowIdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_SubaddressAccount_getAll_size(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccount_getAll_size(
+      subaddressAccount_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccount_getAll_sizePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_SubaddressAccount_getAll_size');
+  late final _WOWNERO_SubaddressAccount_getAll_size =
+      _WOWNERO_SubaddressAccount_getAll_sizePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_SubaddressAccount_getAll_byIndex(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+    int index,
+  ) {
+    return _WOWNERO_SubaddressAccount_getAll_byIndex(
+      subaddressAccount_ptr,
+      index,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccount_getAll_byIndexPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Int)>>('WOWNERO_SubaddressAccount_getAll_byIndex');
+  late final _WOWNERO_SubaddressAccount_getAll_byIndex =
+      _WOWNERO_SubaddressAccount_getAll_byIndexPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_SubaddressAccount_addRow(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_SubaddressAccount_addRow(
+      subaddressAccount_ptr,
+      label,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccount_addRowPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_SubaddressAccount_addRow');
+  late final _WOWNERO_SubaddressAccount_addRow =
+      _WOWNERO_SubaddressAccount_addRowPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_SubaddressAccount_setLabel(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+    int accountIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_SubaddressAccount_setLabel(
+      subaddressAccount_ptr,
+      accountIndex,
+      label,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccount_setLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_SubaddressAccount_setLabel');
+  late final _WOWNERO_SubaddressAccount_setLabel =
+      _WOWNERO_SubaddressAccount_setLabelPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_SubaddressAccount_refresh(
+    ffi.Pointer<ffi.Void> subaddressAccount_ptr,
+  ) {
+    return _WOWNERO_SubaddressAccount_refresh(
+      subaddressAccount_ptr,
+    );
+  }
+
+  late final _WOWNERO_SubaddressAccount_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_SubaddressAccount_refresh');
+  late final _WOWNERO_SubaddressAccount_refresh =
+      _WOWNERO_SubaddressAccount_refreshPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_MultisigState_isMultisig(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _WOWNERO_MultisigState_isMultisig(
+      multisigState_ptr,
+    );
+  }
+
+  late final _WOWNERO_MultisigState_isMultisigPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_MultisigState_isMultisig');
+  late final _WOWNERO_MultisigState_isMultisig =
+      _WOWNERO_MultisigState_isMultisigPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_MultisigState_isReady(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _WOWNERO_MultisigState_isReady(
+      multisigState_ptr,
+    );
+  }
+
+  late final _WOWNERO_MultisigState_isReadyPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_MultisigState_isReady');
+  late final _WOWNERO_MultisigState_isReady = _WOWNERO_MultisigState_isReadyPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_MultisigState_threshold(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _WOWNERO_MultisigState_threshold(
+      multisigState_ptr,
+    );
+  }
+
+  late final _WOWNERO_MultisigState_thresholdPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_MultisigState_threshold');
+  late final _WOWNERO_MultisigState_threshold =
+      _WOWNERO_MultisigState_thresholdPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_MultisigState_total(
+    ffi.Pointer<ffi.Void> multisigState_ptr,
+  ) {
+    return _WOWNERO_MultisigState_total(
+      multisigState_ptr,
+    );
+  }
+
+  late final _WOWNERO_MultisigState_totalPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_MultisigState_total');
+  late final _WOWNERO_MultisigState_total = _WOWNERO_MultisigState_totalPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_DeviceProgress_progress(
+    ffi.Pointer<ffi.Void> deviceProgress_ptr,
+  ) {
+    return _WOWNERO_DeviceProgress_progress(
+      deviceProgress_ptr,
+    );
+  }
+
+  late final _WOWNERO_DeviceProgress_progressPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_DeviceProgress_progress');
+  late final _WOWNERO_DeviceProgress_progress =
+      _WOWNERO_DeviceProgress_progressPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_DeviceProgress_indeterminate(
+    ffi.Pointer<ffi.Void> deviceProgress_ptr,
+  ) {
+    return _WOWNERO_DeviceProgress_indeterminate(
+      deviceProgress_ptr,
+    );
+  }
+
+  late final _WOWNERO_DeviceProgress_indeterminatePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_DeviceProgress_indeterminate');
+  late final _WOWNERO_DeviceProgress_indeterminate =
+      _WOWNERO_DeviceProgress_indeterminatePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_seed(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> seed_offset,
+  ) {
+    return _WOWNERO_Wallet_seed(
+      wallet_ptr,
+      seed_offset,
+    );
+  }
+
+  late final _WOWNERO_Wallet_seedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_seed');
+  late final _WOWNERO_Wallet_seed = _WOWNERO_Wallet_seedPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(
+          ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getSeedLanguage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getSeedLanguage(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getSeedLanguagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_getSeedLanguage');
+  late final _WOWNERO_Wallet_getSeedLanguage =
+      _WOWNERO_Wallet_getSeedLanguagePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_setSeedLanguage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> arg,
+  ) {
+    return _WOWNERO_Wallet_setSeedLanguage(
+      wallet_ptr,
+      arg,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setSeedLanguagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setSeedLanguage');
+  late final _WOWNERO_Wallet_setSeedLanguage =
+      _WOWNERO_Wallet_setSeedLanguagePtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_Wallet_status(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_status(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_statusPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_status');
+  late final _WOWNERO_Wallet_status = _WOWNERO_Wallet_statusPtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_errorString(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_errorString(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_errorString');
+  late final _WOWNERO_Wallet_errorString = _WOWNERO_Wallet_errorStringPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_setPassword(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> password,
+  ) {
+    return _WOWNERO_Wallet_setPassword(
+      wallet_ptr,
+      password,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setPasswordPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setPassword');
+  late final _WOWNERO_Wallet_setPassword =
+      _WOWNERO_Wallet_setPasswordPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getPassword(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getPassword(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getPasswordPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_getPassword');
+  late final _WOWNERO_Wallet_getPassword = _WOWNERO_Wallet_getPasswordPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_setDevicePin(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> pin,
+  ) {
+    return _WOWNERO_Wallet_setDevicePin(
+      wallet_ptr,
+      pin,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setDevicePinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setDevicePin');
+  late final _WOWNERO_Wallet_setDevicePin =
+      _WOWNERO_Wallet_setDevicePinPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_setDevicePassphrase(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> passphrase,
+  ) {
+    return _WOWNERO_Wallet_setDevicePassphrase(
+      wallet_ptr,
+      passphrase,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setDevicePassphrasePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setDevicePassphrase');
+  late final _WOWNERO_Wallet_setDevicePassphrase =
+      _WOWNERO_Wallet_setDevicePassphrasePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_address(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+  ) {
+    return _WOWNERO_Wallet_address(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_addressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
+              ffi.Uint64)>>('WOWNERO_Wallet_address');
+  late final _WOWNERO_Wallet_address = _WOWNERO_Wallet_addressPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_path(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_path(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_pathPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_path');
+  late final _WOWNERO_Wallet_path = _WOWNERO_Wallet_pathPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_nettype(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_nettype(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_nettypePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_nettype');
+  late final _WOWNERO_Wallet_nettype = _WOWNERO_Wallet_nettypePtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_useForkRules(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int version,
+    int early_blocks,
+  ) {
+    return _WOWNERO_Wallet_useForkRules(
+      wallet_ptr,
+      version,
+      early_blocks,
+    );
+  }
+
+  late final _WOWNERO_Wallet_useForkRulesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint8 Function(ffi.Pointer<ffi.Void>, ffi.Uint8,
+              ffi.Int64)>>('WOWNERO_Wallet_useForkRules');
+  late final _WOWNERO_Wallet_useForkRules = _WOWNERO_Wallet_useForkRulesPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_integratedAddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> payment_id,
+  ) {
+    return _WOWNERO_Wallet_integratedAddress(
+      wallet_ptr,
+      payment_id,
+    );
+  }
+
+  late final _WOWNERO_Wallet_integratedAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_integratedAddress');
+  late final _WOWNERO_Wallet_integratedAddress =
+      _WOWNERO_Wallet_integratedAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_secretViewKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_secretViewKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_secretViewKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_secretViewKey');
+  late final _WOWNERO_Wallet_secretViewKey = _WOWNERO_Wallet_secretViewKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_publicViewKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_publicViewKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_publicViewKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_publicViewKey');
+  late final _WOWNERO_Wallet_publicViewKey = _WOWNERO_Wallet_publicViewKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_secretSpendKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_secretSpendKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_secretSpendKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_secretSpendKey');
+  late final _WOWNERO_Wallet_secretSpendKey = _WOWNERO_Wallet_secretSpendKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_publicSpendKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_publicSpendKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_publicSpendKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_publicSpendKey');
+  late final _WOWNERO_Wallet_publicSpendKey = _WOWNERO_Wallet_publicSpendKeyPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_publicMultisigSignerKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_publicMultisigSignerKey(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_publicMultisigSignerKeyPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>>(
+      'WOWNERO_Wallet_publicMultisigSignerKey');
+  late final _WOWNERO_Wallet_publicMultisigSignerKey =
+      _WOWNERO_Wallet_publicMultisigSignerKeyPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_stop(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_stop(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_stopPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_stop');
+  late final _WOWNERO_Wallet_stop = _WOWNERO_Wallet_stopPtr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_store(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> path,
+  ) {
+    return _WOWNERO_Wallet_store(
+      wallet_ptr,
+      path,
+    );
+  }
+
+  late final _WOWNERO_Wallet_storePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_store');
+  late final _WOWNERO_Wallet_store = _WOWNERO_Wallet_storePtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_filename(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_filename(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_filenamePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_filename');
+  late final _WOWNERO_Wallet_filename = _WOWNERO_Wallet_filenamePtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_keysFilename(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_keysFilename(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_keysFilenamePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_keysFilename');
+  late final _WOWNERO_Wallet_keysFilename = _WOWNERO_Wallet_keysFilenamePtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_init(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> daemon_address,
+    int upper_transaction_size_limit,
+    ffi.Pointer<ffi.Char> daemon_username,
+    ffi.Pointer<ffi.Char> daemon_password,
+    bool use_ssl,
+    bool lightWallet,
+    ffi.Pointer<ffi.Char> proxy_address,
+  ) {
+    return _WOWNERO_Wallet_init(
+      wallet_ptr,
+      daemon_address,
+      upper_transaction_size_limit,
+      daemon_username,
+      daemon_password,
+      use_ssl,
+      lightWallet,
+      proxy_address,
+    );
+  }
+
+  late final _WOWNERO_Wallet_initPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Bool,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_init');
+  late final _WOWNERO_Wallet_init = _WOWNERO_Wallet_initPtr.asFunction<
+      bool Function(
+          ffi.Pointer<ffi.Void>,
+          ffi.Pointer<ffi.Char>,
+          int,
+          ffi.Pointer<ffi.Char>,
+          ffi.Pointer<ffi.Char>,
+          bool,
+          bool,
+          ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_createWatchOnly(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+  ) {
+    return _WOWNERO_Wallet_createWatchOnly(
+      wallet_ptr,
+      path,
+      password,
+      language,
+    );
+  }
+
+  late final _WOWNERO_Wallet_createWatchOnlyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_createWatchOnly');
+  late final _WOWNERO_Wallet_createWatchOnly =
+      _WOWNERO_Wallet_createWatchOnlyPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_Wallet_setRefreshFromBlockHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int refresh_from_block_height,
+  ) {
+    return _WOWNERO_Wallet_setRefreshFromBlockHeight(
+      wallet_ptr,
+      refresh_from_block_height,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setRefreshFromBlockHeightPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint64)>>('WOWNERO_Wallet_setRefreshFromBlockHeight');
+  late final _WOWNERO_Wallet_setRefreshFromBlockHeight =
+      _WOWNERO_Wallet_setRefreshFromBlockHeightPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_Wallet_getRefreshFromBlockHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getRefreshFromBlockHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getRefreshFromBlockHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_getRefreshFromBlockHeight');
+  late final _WOWNERO_Wallet_getRefreshFromBlockHeight =
+      _WOWNERO_Wallet_getRefreshFromBlockHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_setRecoveringFromSeed(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool recoveringFromSeed,
+  ) {
+    return _WOWNERO_Wallet_setRecoveringFromSeed(
+      wallet_ptr,
+      recoveringFromSeed,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setRecoveringFromSeedPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'WOWNERO_Wallet_setRecoveringFromSeed');
+  late final _WOWNERO_Wallet_setRecoveringFromSeed =
+      _WOWNERO_Wallet_setRecoveringFromSeedPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  void WOWNERO_Wallet_setRecoveringFromDevice(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool recoveringFromDevice,
+  ) {
+    return _WOWNERO_Wallet_setRecoveringFromDevice(
+      wallet_ptr,
+      recoveringFromDevice,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setRecoveringFromDevicePtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'WOWNERO_Wallet_setRecoveringFromDevice');
+  late final _WOWNERO_Wallet_setRecoveringFromDevice =
+      _WOWNERO_Wallet_setRecoveringFromDevicePtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  void WOWNERO_Wallet_setSubaddressLookahead(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int major,
+    int minor,
+  ) {
+    return _WOWNERO_Wallet_setSubaddressLookahead(
+      wallet_ptr,
+      major,
+      minor,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setSubaddressLookaheadPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Uint32)>>('WOWNERO_Wallet_setSubaddressLookahead');
+  late final _WOWNERO_Wallet_setSubaddressLookahead =
+      _WOWNERO_Wallet_setSubaddressLookaheadPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  bool WOWNERO_Wallet_connectToDaemon(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_connectToDaemon(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_connectToDaemonPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_connectToDaemon');
+  late final _WOWNERO_Wallet_connectToDaemon =
+      _WOWNERO_Wallet_connectToDaemonPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_connected(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_connected(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_connectedPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_connected');
+  late final _WOWNERO_Wallet_connected = _WOWNERO_Wallet_connectedPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_setTrustedDaemon(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool arg,
+  ) {
+    return _WOWNERO_Wallet_setTrustedDaemon(
+      wallet_ptr,
+      arg,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setTrustedDaemonPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'WOWNERO_Wallet_setTrustedDaemon');
+  late final _WOWNERO_Wallet_setTrustedDaemon =
+      _WOWNERO_Wallet_setTrustedDaemonPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  bool WOWNERO_Wallet_trustedDaemon(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_trustedDaemon(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_trustedDaemonPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_trustedDaemon');
+  late final _WOWNERO_Wallet_trustedDaemon = _WOWNERO_Wallet_trustedDaemonPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_setProxy(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _WOWNERO_Wallet_setProxy(
+      wallet_ptr,
+      address,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setProxyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setProxy');
+  late final _WOWNERO_Wallet_setProxy = _WOWNERO_Wallet_setProxyPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_Wallet_balance(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _WOWNERO_Wallet_balance(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_balancePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(
+              ffi.Pointer<ffi.Void>, ffi.Uint32)>>('WOWNERO_Wallet_balance');
+  late final _WOWNERO_Wallet_balance = _WOWNERO_Wallet_balancePtr.asFunction<
+      int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_Wallet_unlockedBalance(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _WOWNERO_Wallet_unlockedBalance(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_unlockedBalancePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('WOWNERO_Wallet_unlockedBalance');
+  late final _WOWNERO_Wallet_unlockedBalance =
+      _WOWNERO_Wallet_unlockedBalancePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_Wallet_viewOnlyBalance(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _WOWNERO_Wallet_viewOnlyBalance(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_viewOnlyBalancePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('WOWNERO_Wallet_viewOnlyBalance');
+  late final _WOWNERO_Wallet_viewOnlyBalance =
+      _WOWNERO_Wallet_viewOnlyBalancePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool WOWNERO_Wallet_watchOnly(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_watchOnly(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_watchOnlyPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_watchOnly');
+  late final _WOWNERO_Wallet_watchOnly = _WOWNERO_Wallet_watchOnlyPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_isDeterministic(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_isDeterministic(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_isDeterministicPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_isDeterministic');
+  late final _WOWNERO_Wallet_isDeterministic =
+      _WOWNERO_Wallet_isDeterministicPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_blockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_blockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_blockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_blockChainHeight');
+  late final _WOWNERO_Wallet_blockChainHeight =
+      _WOWNERO_Wallet_blockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_approximateBlockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_approximateBlockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_approximateBlockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_approximateBlockChainHeight');
+  late final _WOWNERO_Wallet_approximateBlockChainHeight =
+      _WOWNERO_Wallet_approximateBlockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_estimateBlockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_estimateBlockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_estimateBlockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_estimateBlockChainHeight');
+  late final _WOWNERO_Wallet_estimateBlockChainHeight =
+      _WOWNERO_Wallet_estimateBlockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_daemonBlockChainHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_daemonBlockChainHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_daemonBlockChainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_daemonBlockChainHeight');
+  late final _WOWNERO_Wallet_daemonBlockChainHeight =
+      _WOWNERO_Wallet_daemonBlockChainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_daemonBlockChainHeight_cached(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_daemonBlockChainHeight_cached(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_daemonBlockChainHeight_cached');
+  late final _WOWNERO_Wallet_daemonBlockChainHeight_cached =
+      _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_daemonBlockChainHeight_runThread(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int seconds,
+  ) {
+    return _WOWNERO_Wallet_daemonBlockChainHeight_runThread(
+      wallet_ptr,
+      seconds,
+    );
+  }
+
+  late final _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'WOWNERO_Wallet_daemonBlockChainHeight_runThread');
+  late final _WOWNERO_Wallet_daemonBlockChainHeight_runThread =
+      _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_Wallet_daemonBlockChainTargetHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_daemonBlockChainTargetHeight(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_daemonBlockChainTargetHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_daemonBlockChainTargetHeight');
+  late final _WOWNERO_Wallet_daemonBlockChainTargetHeight =
+      _WOWNERO_Wallet_daemonBlockChainTargetHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_synchronized(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_synchronized(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_synchronizedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_synchronized');
+  late final _WOWNERO_Wallet_synchronized = _WOWNERO_Wallet_synchronizedPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_displayAmount(
+    int amount,
+  ) {
+    return _WOWNERO_Wallet_displayAmount(
+      amount,
+    );
+  }
+
+  late final _WOWNERO_Wallet_displayAmountPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function(ffi.Uint64)>>(
+          'WOWNERO_Wallet_displayAmount');
+  late final _WOWNERO_Wallet_displayAmount = _WOWNERO_Wallet_displayAmountPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(int)>();
+
+  int WOWNERO_Wallet_amountFromString(
+    ffi.Pointer<ffi.Char> amount,
+  ) {
+    return _WOWNERO_Wallet_amountFromString(
+      amount,
+    );
+  }
+
+  late final _WOWNERO_Wallet_amountFromStringPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Char>)>>(
+          'WOWNERO_Wallet_amountFromString');
+  late final _WOWNERO_Wallet_amountFromString =
+      _WOWNERO_Wallet_amountFromStringPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_Wallet_amountFromDouble(
+    double amount,
+  ) {
+    return _WOWNERO_Wallet_amountFromDouble(
+      amount,
+    );
+  }
+
+  late final _WOWNERO_Wallet_amountFromDoublePtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Double)>>(
+          'WOWNERO_Wallet_amountFromDouble');
+  late final _WOWNERO_Wallet_amountFromDouble =
+      _WOWNERO_Wallet_amountFromDoublePtr.asFunction<int Function(double)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_genPaymentId() {
+    return _WOWNERO_Wallet_genPaymentId();
+  }
+
+  late final _WOWNERO_Wallet_genPaymentIdPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
+          'WOWNERO_Wallet_genPaymentId');
+  late final _WOWNERO_Wallet_genPaymentId = _WOWNERO_Wallet_genPaymentIdPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function()>();
+
+  bool WOWNERO_Wallet_paymentIdValid(
+    ffi.Pointer<ffi.Char> paiment_id,
+  ) {
+    return _WOWNERO_Wallet_paymentIdValid(
+      paiment_id,
+    );
+  }
+
+  late final _WOWNERO_Wallet_paymentIdValidPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>)>>(
+          'WOWNERO_Wallet_paymentIdValid');
+  late final _WOWNERO_Wallet_paymentIdValid = _WOWNERO_Wallet_paymentIdValidPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_addressValid(
+    ffi.Pointer<ffi.Char> str,
+    int nettype,
+  ) {
+    return _WOWNERO_Wallet_addressValid(
+      str,
+      nettype,
+    );
+  }
+
+  late final _WOWNERO_Wallet_addressValidPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Char>, ffi.Int)>>(
+      'WOWNERO_Wallet_addressValid');
+  late final _WOWNERO_Wallet_addressValid = _WOWNERO_Wallet_addressValidPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Char>, int)>();
+
+  bool WOWNERO_Wallet_keyValid(
+    ffi.Pointer<ffi.Char> secret_key_string,
+    ffi.Pointer<ffi.Char> address_string,
+    bool isViewKey,
+    int nettype,
+  ) {
+    return _WOWNERO_Wallet_keyValid(
+      secret_key_string,
+      address_string,
+      isViewKey,
+      nettype,
+    );
+  }
+
+  late final _WOWNERO_Wallet_keyValidPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>,
+              ffi.Bool, ffi.Int)>>('WOWNERO_Wallet_keyValid');
+  late final _WOWNERO_Wallet_keyValid = _WOWNERO_Wallet_keyValidPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_keyValid_error(
+    ffi.Pointer<ffi.Char> secret_key_string,
+    ffi.Pointer<ffi.Char> address_string,
+    bool isViewKey,
+    int nettype,
+  ) {
+    return _WOWNERO_Wallet_keyValid_error(
+      secret_key_string,
+      address_string,
+      isViewKey,
+      nettype,
+    );
+  }
+
+  late final _WOWNERO_Wallet_keyValid_errorPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Int)>>('WOWNERO_Wallet_keyValid_error');
+  late final _WOWNERO_Wallet_keyValid_error =
+      _WOWNERO_Wallet_keyValid_errorPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_paymentIdFromAddress(
+    ffi.Pointer<ffi.Char> strarg,
+    int nettype,
+  ) {
+    return _WOWNERO_Wallet_paymentIdFromAddress(
+      strarg,
+      nettype,
+    );
+  }
+
+  late final _WOWNERO_Wallet_paymentIdFromAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>,
+              ffi.Int)>>('WOWNERO_Wallet_paymentIdFromAddress');
+  late final _WOWNERO_Wallet_paymentIdFromAddress =
+      _WOWNERO_Wallet_paymentIdFromAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>, int)>();
+
+  int WOWNERO_Wallet_maximumAllowedAmount() {
+    return _WOWNERO_Wallet_maximumAllowedAmount();
+  }
+
+  late final _WOWNERO_Wallet_maximumAllowedAmountPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function()>>(
+          'WOWNERO_Wallet_maximumAllowedAmount');
+  late final _WOWNERO_Wallet_maximumAllowedAmount =
+      _WOWNERO_Wallet_maximumAllowedAmountPtr.asFunction<int Function()>();
+
+  void WOWNERO_Wallet_init3(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> argv0,
+    ffi.Pointer<ffi.Char> default_log_base_name,
+    ffi.Pointer<ffi.Char> log_path,
+    bool console,
+  ) {
+    return _WOWNERO_Wallet_init3(
+      wallet_ptr,
+      argv0,
+      default_log_base_name,
+      log_path,
+      console,
+    );
+  }
+
+  late final _WOWNERO_Wallet_init3Ptr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('WOWNERO_Wallet_init3');
+  late final _WOWNERO_Wallet_init3 = _WOWNERO_Wallet_init3Ptr.asFunction<
+      void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+          ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, bool)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getPolyseed(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> passphrase,
+  ) {
+    return _WOWNERO_Wallet_getPolyseed(
+      wallet_ptr,
+      passphrase,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getPolyseedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getPolyseed');
+  late final _WOWNERO_Wallet_getPolyseed =
+      _WOWNERO_Wallet_getPolyseedPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_createPolyseed(
+    ffi.Pointer<ffi.Char> language,
+  ) {
+    return _WOWNERO_Wallet_createPolyseed(
+      language,
+    );
+  }
+
+  late final _WOWNERO_Wallet_createPolyseedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_createPolyseed');
+  late final _WOWNERO_Wallet_createPolyseed = _WOWNERO_Wallet_createPolyseedPtr
+      .asFunction<ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_Wallet_startRefresh(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_startRefresh(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_startRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_startRefresh');
+  late final _WOWNERO_Wallet_startRefresh = _WOWNERO_Wallet_startRefreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_pauseRefresh(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_pauseRefresh(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_pauseRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_pauseRefresh');
+  late final _WOWNERO_Wallet_pauseRefresh = _WOWNERO_Wallet_pauseRefreshPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_refresh(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_refresh(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_refreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_refresh');
+  late final _WOWNERO_Wallet_refresh = _WOWNERO_Wallet_refreshPtr.asFunction<
+      bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_refreshAsync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_refreshAsync(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_refreshAsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_refreshAsync');
+  late final _WOWNERO_Wallet_refreshAsync = _WOWNERO_Wallet_refreshAsyncPtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_rescanBlockchain(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_rescanBlockchain(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_rescanBlockchainPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_rescanBlockchain');
+  late final _WOWNERO_Wallet_rescanBlockchain =
+      _WOWNERO_Wallet_rescanBlockchainPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_rescanBlockchainAsync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_rescanBlockchainAsync(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_rescanBlockchainAsyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_rescanBlockchainAsync');
+  late final _WOWNERO_Wallet_rescanBlockchainAsync =
+      _WOWNERO_Wallet_rescanBlockchainAsyncPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_setAutoRefreshInterval(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int millis,
+  ) {
+    return _WOWNERO_Wallet_setAutoRefreshInterval(
+      wallet_ptr,
+      millis,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setAutoRefreshIntervalPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Int)>>(
+      'WOWNERO_Wallet_setAutoRefreshInterval');
+  late final _WOWNERO_Wallet_setAutoRefreshInterval =
+      _WOWNERO_Wallet_setAutoRefreshIntervalPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  int WOWNERO_Wallet_autoRefreshInterval(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_autoRefreshInterval(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_autoRefreshIntervalPtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_autoRefreshInterval');
+  late final _WOWNERO_Wallet_autoRefreshInterval =
+      _WOWNERO_Wallet_autoRefreshIntervalPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_addSubaddressAccount(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_Wallet_addSubaddressAccount(
+      wallet_ptr,
+      label,
+    );
+  }
+
+  late final _WOWNERO_Wallet_addSubaddressAccountPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_addSubaddressAccount');
+  late final _WOWNERO_Wallet_addSubaddressAccount =
+      _WOWNERO_Wallet_addSubaddressAccountPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_Wallet_numSubaddressAccounts(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_numSubaddressAccounts(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_numSubaddressAccountsPtr =
+      _lookup<ffi.NativeFunction<ffi.Size Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_numSubaddressAccounts');
+  late final _WOWNERO_Wallet_numSubaddressAccounts =
+      _WOWNERO_Wallet_numSubaddressAccountsPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_numSubaddresses(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+  ) {
+    return _WOWNERO_Wallet_numSubaddresses(
+      wallet_ptr,
+      accountIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_numSubaddressesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Size Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('WOWNERO_Wallet_numSubaddresses');
+  late final _WOWNERO_Wallet_numSubaddresses =
+      _WOWNERO_Wallet_numSubaddressesPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_Wallet_addSubaddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_Wallet_addSubaddress(
+      wallet_ptr,
+      accountIndex,
+      label,
+    );
+  }
+
+  late final _WOWNERO_Wallet_addSubaddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_addSubaddress');
+  late final _WOWNERO_Wallet_addSubaddress =
+      _WOWNERO_Wallet_addSubaddressPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getSubaddressLabel(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+  ) {
+    return _WOWNERO_Wallet_getSubaddressLabel(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getSubaddressLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Uint32)>>('WOWNERO_Wallet_getSubaddressLabel');
+  late final _WOWNERO_Wallet_getSubaddressLabel =
+      _WOWNERO_Wallet_getSubaddressLabelPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  void WOWNERO_Wallet_setSubaddressLabel(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+    ffi.Pointer<ffi.Char> label,
+  ) {
+    return _WOWNERO_Wallet_setSubaddressLabel(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+      label,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setSubaddressLabelPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Uint32, ffi.Uint32,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setSubaddressLabel');
+  late final _WOWNERO_Wallet_setSubaddressLabel =
+      _WOWNERO_Wallet_setSubaddressLabelPtr.asFunction<
+          void Function(
+              ffi.Pointer<ffi.Void>, int, int, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getMultisigInfo(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getMultisigInfo(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getMultisigInfoPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_getMultisigInfo');
+  late final _WOWNERO_Wallet_getMultisigInfo =
+      _WOWNERO_Wallet_getMultisigInfoPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_createTransactionMultDest(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> dst_addr_list,
+    ffi.Pointer<ffi.Char> dst_addr_list_separator,
+    ffi.Pointer<ffi.Char> payment_id,
+    bool amount_sweep_all,
+    ffi.Pointer<ffi.Char> amount_list,
+    ffi.Pointer<ffi.Char> amount_list_separator,
+    int mixin_count,
+    int pendingTransactionPriority,
+    int subaddr_account,
+    ffi.Pointer<ffi.Char> preferredInputs,
+    ffi.Pointer<ffi.Char> preferredInputs_separator,
+  ) {
+    return _WOWNERO_Wallet_createTransactionMultDest(
+      wallet_ptr,
+      dst_addr_list,
+      dst_addr_list_separator,
+      payment_id,
+      amount_sweep_all,
+      amount_list,
+      amount_list_separator,
+      mixin_count,
+      pendingTransactionPriority,
+      subaddr_account,
+      preferredInputs,
+      preferredInputs_separator,
+    );
+  }
+
+  late final _WOWNERO_Wallet_createTransactionMultDestPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<ffi.Void> Function(
+                  ffi.Pointer<ffi.Void>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Bool,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Uint32,
+                  ffi.Int,
+                  ffi.Uint32,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_Wallet_createTransactionMultDest');
+  late final _WOWNERO_Wallet_createTransactionMultDest =
+      _WOWNERO_Wallet_createTransactionMultDestPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              bool,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_createTransaction(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> dst_addr,
+    ffi.Pointer<ffi.Char> payment_id,
+    int amount,
+    int mixin_count,
+    int pendingTransactionPriority,
+    int subaddr_account,
+    ffi.Pointer<ffi.Char> preferredInputs,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_Wallet_createTransaction(
+      wallet_ptr,
+      dst_addr,
+      payment_id,
+      amount,
+      mixin_count,
+      pendingTransactionPriority,
+      subaddr_account,
+      preferredInputs,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_Wallet_createTransactionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64,
+              ffi.Uint32,
+              ffi.Int,
+              ffi.Uint32,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_createTransaction');
+  late final _WOWNERO_Wallet_createTransaction =
+      _WOWNERO_Wallet_createTransactionPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_loadUnsignedTx(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> unsigned_filename,
+  ) {
+    return _WOWNERO_Wallet_loadUnsignedTx(
+      wallet_ptr,
+      unsigned_filename,
+    );
+  }
+
+  late final _WOWNERO_Wallet_loadUnsignedTxPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_loadUnsignedTx');
+  late final _WOWNERO_Wallet_loadUnsignedTx =
+      _WOWNERO_Wallet_loadUnsignedTxPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_submitTransaction(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> fileName,
+  ) {
+    return _WOWNERO_Wallet_submitTransaction(
+      wallet_ptr,
+      fileName,
+    );
+  }
+
+  late final _WOWNERO_Wallet_submitTransactionPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_submitTransaction');
+  late final _WOWNERO_Wallet_submitTransaction =
+      _WOWNERO_Wallet_submitTransactionPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_hasUnknownKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_hasUnknownKeyImages(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_hasUnknownKeyImagesPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_hasUnknownKeyImages');
+  late final _WOWNERO_Wallet_hasUnknownKeyImages =
+      _WOWNERO_Wallet_hasUnknownKeyImagesPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_exportKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+    bool all,
+  ) {
+    return _WOWNERO_Wallet_exportKeyImages(
+      wallet_ptr,
+      filename,
+      all,
+    );
+  }
+
+  late final _WOWNERO_Wallet_exportKeyImagesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('WOWNERO_Wallet_exportKeyImages');
+  late final _WOWNERO_Wallet_exportKeyImages =
+      _WOWNERO_Wallet_exportKeyImagesPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  bool WOWNERO_Wallet_importKeyImages(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+  ) {
+    return _WOWNERO_Wallet_importKeyImages(
+      wallet_ptr,
+      filename,
+    );
+  }
+
+  late final _WOWNERO_Wallet_importKeyImagesPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_importKeyImages');
+  late final _WOWNERO_Wallet_importKeyImages =
+      _WOWNERO_Wallet_importKeyImagesPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_exportOutputs(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+    bool all,
+  ) {
+    return _WOWNERO_Wallet_exportOutputs(
+      wallet_ptr,
+      filename,
+      all,
+    );
+  }
+
+  late final _WOWNERO_Wallet_exportOutputsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('WOWNERO_Wallet_exportOutputs');
+  late final _WOWNERO_Wallet_exportOutputs =
+      _WOWNERO_Wallet_exportOutputsPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  bool WOWNERO_Wallet_importOutputs(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> filename,
+  ) {
+    return _WOWNERO_Wallet_importOutputs(
+      wallet_ptr,
+      filename,
+    );
+  }
+
+  late final _WOWNERO_Wallet_importOutputsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_importOutputs');
+  late final _WOWNERO_Wallet_importOutputs =
+      _WOWNERO_Wallet_importOutputsPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_setupBackgroundSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int background_sync_type,
+    ffi.Pointer<ffi.Char> wallet_password,
+    ffi.Pointer<ffi.Char> background_cache_password,
+  ) {
+    return _WOWNERO_Wallet_setupBackgroundSync(
+      wallet_ptr,
+      background_sync_type,
+      wallet_password,
+      background_cache_password,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setupBackgroundSyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setupBackgroundSync');
+  late final _WOWNERO_Wallet_setupBackgroundSync =
+      _WOWNERO_Wallet_setupBackgroundSyncPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, int, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_Wallet_getBackgroundSyncType(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getBackgroundSyncType(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getBackgroundSyncTypePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_getBackgroundSyncType');
+  late final _WOWNERO_Wallet_getBackgroundSyncType =
+      _WOWNERO_Wallet_getBackgroundSyncTypePtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_startBackgroundSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_startBackgroundSync(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_startBackgroundSyncPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_startBackgroundSync');
+  late final _WOWNERO_Wallet_startBackgroundSync =
+      _WOWNERO_Wallet_startBackgroundSyncPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_stopBackgroundSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> wallet_password,
+  ) {
+    return _WOWNERO_Wallet_stopBackgroundSync(
+      wallet_ptr,
+      wallet_password,
+    );
+  }
+
+  late final _WOWNERO_Wallet_stopBackgroundSyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_stopBackgroundSync');
+  late final _WOWNERO_Wallet_stopBackgroundSync =
+      _WOWNERO_Wallet_stopBackgroundSyncPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_isBackgroundSyncing(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_isBackgroundSyncing(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_isBackgroundSyncingPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_isBackgroundSyncing');
+  late final _WOWNERO_Wallet_isBackgroundSyncing =
+      _WOWNERO_Wallet_isBackgroundSyncingPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_isBackgroundWallet(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_isBackgroundWallet(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_isBackgroundWalletPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_isBackgroundWallet');
+  late final _WOWNERO_Wallet_isBackgroundWallet =
+      _WOWNERO_Wallet_isBackgroundWalletPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_history(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_history(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_historyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_history');
+  late final _WOWNERO_Wallet_history = _WOWNERO_Wallet_historyPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_addressBook(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_addressBook(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_addressBookPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_addressBook');
+  late final _WOWNERO_Wallet_addressBook = _WOWNERO_Wallet_addressBookPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_coins(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_coins(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_coinsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_coins');
+  late final _WOWNERO_Wallet_coins = _WOWNERO_Wallet_coinsPtr.asFunction<
+      ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_subaddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_subaddress(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_subaddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_subaddress');
+  late final _WOWNERO_Wallet_subaddress = _WOWNERO_Wallet_subaddressPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_Wallet_subaddressAccount(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_subaddressAccount(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_subaddressAccountPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_Wallet_subaddressAccount');
+  late final _WOWNERO_Wallet_subaddressAccount =
+      _WOWNERO_Wallet_subaddressAccountPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_defaultMixin(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_defaultMixin(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_defaultMixinPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint32 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_defaultMixin');
+  late final _WOWNERO_Wallet_defaultMixin = _WOWNERO_Wallet_defaultMixinPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_setDefaultMixin(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int arg,
+  ) {
+    return _WOWNERO_Wallet_setDefaultMixin(
+      wallet_ptr,
+      arg,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setDefaultMixinPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint32)>>('WOWNERO_Wallet_setDefaultMixin');
+  late final _WOWNERO_Wallet_setDefaultMixin =
+      _WOWNERO_Wallet_setDefaultMixinPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  bool WOWNERO_Wallet_setCacheAttribute(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> key,
+    ffi.Pointer<ffi.Char> val,
+  ) {
+    return _WOWNERO_Wallet_setCacheAttribute(
+      wallet_ptr,
+      key,
+      val,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setCacheAttributePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setCacheAttribute');
+  late final _WOWNERO_Wallet_setCacheAttribute =
+      _WOWNERO_Wallet_setCacheAttributePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getCacheAttribute(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> key,
+  ) {
+    return _WOWNERO_Wallet_getCacheAttribute(
+      wallet_ptr,
+      key,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getCacheAttributePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getCacheAttribute');
+  late final _WOWNERO_Wallet_getCacheAttribute =
+      _WOWNERO_Wallet_getCacheAttributePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_setUserNote(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> txid,
+    ffi.Pointer<ffi.Char> note,
+  ) {
+    return _WOWNERO_Wallet_setUserNote(
+      wallet_ptr,
+      txid,
+      note,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setUserNotePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_setUserNote');
+  late final _WOWNERO_Wallet_setUserNote =
+      _WOWNERO_Wallet_setUserNotePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getUserNote(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> txid,
+  ) {
+    return _WOWNERO_Wallet_getUserNote(
+      wallet_ptr,
+      txid,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getUserNotePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getUserNote');
+  late final _WOWNERO_Wallet_getUserNote =
+      _WOWNERO_Wallet_getUserNotePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_getTxKey(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> txid,
+  ) {
+    return _WOWNERO_Wallet_getTxKey(
+      wallet_ptr,
+      txid,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getTxKeyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_getTxKey');
+  late final _WOWNERO_Wallet_getTxKey = _WOWNERO_Wallet_getTxKeyPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function(
+          ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_signMessage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> message,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _WOWNERO_Wallet_signMessage(
+      wallet_ptr,
+      message,
+      address,
+    );
+  }
+
+  late final _WOWNERO_Wallet_signMessagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_signMessage');
+  late final _WOWNERO_Wallet_signMessage =
+      _WOWNERO_Wallet_signMessagePtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_verifySignedMessage(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    ffi.Pointer<ffi.Char> message,
+    ffi.Pointer<ffi.Char> address,
+    ffi.Pointer<ffi.Char> signature,
+  ) {
+    return _WOWNERO_Wallet_verifySignedMessage(
+      wallet_ptr,
+      message,
+      address,
+      signature,
+    );
+  }
+
+  late final _WOWNERO_Wallet_verifySignedMessagePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_Wallet_verifySignedMessage');
+  late final _WOWNERO_Wallet_verifySignedMessage =
+      _WOWNERO_Wallet_verifySignedMessagePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_Wallet_rescanSpent(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_rescanSpent(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_rescanSpentPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_rescanSpent');
+  late final _WOWNERO_Wallet_rescanSpent = _WOWNERO_Wallet_rescanSpentPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_setOffline(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool offline,
+  ) {
+    return _WOWNERO_Wallet_setOffline(
+      wallet_ptr,
+      offline,
+    );
+  }
+
+  late final _WOWNERO_Wallet_setOfflinePtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'WOWNERO_Wallet_setOffline');
+  late final _WOWNERO_Wallet_setOffline = _WOWNERO_Wallet_setOfflinePtr
+      .asFunction<void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  bool WOWNERO_Wallet_isOffline(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_isOffline(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_isOfflinePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_isOffline');
+  late final _WOWNERO_Wallet_isOffline = _WOWNERO_Wallet_isOfflinePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_Wallet_segregatePreForkOutputs(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool segregate,
+  ) {
+    return _WOWNERO_Wallet_segregatePreForkOutputs(
+      wallet_ptr,
+      segregate,
+    );
+  }
+
+  late final _WOWNERO_Wallet_segregatePreForkOutputsPtr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'WOWNERO_Wallet_segregatePreForkOutputs');
+  late final _WOWNERO_Wallet_segregatePreForkOutputs =
+      _WOWNERO_Wallet_segregatePreForkOutputsPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  void WOWNERO_Wallet_segregationHeight(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int height,
+  ) {
+    return _WOWNERO_Wallet_segregationHeight(
+      wallet_ptr,
+      height,
+    );
+  }
+
+  late final _WOWNERO_Wallet_segregationHeightPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(ffi.Pointer<ffi.Void>,
+              ffi.Uint64)>>('WOWNERO_Wallet_segregationHeight');
+  late final _WOWNERO_Wallet_segregationHeight =
+      _WOWNERO_Wallet_segregationHeightPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, int)>();
+
+  void WOWNERO_Wallet_keyReuseMitigation2(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool mitigation,
+  ) {
+    return _WOWNERO_Wallet_keyReuseMitigation2(
+      wallet_ptr,
+      mitigation,
+    );
+  }
+
+  late final _WOWNERO_Wallet_keyReuseMitigation2Ptr = _lookup<
+          ffi
+          .NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Bool)>>(
+      'WOWNERO_Wallet_keyReuseMitigation2');
+  late final _WOWNERO_Wallet_keyReuseMitigation2 =
+      _WOWNERO_Wallet_keyReuseMitigation2Ptr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, bool)>();
+
+  bool WOWNERO_Wallet_lockKeysFile(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_lockKeysFile(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_lockKeysFilePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_lockKeysFile');
+  late final _WOWNERO_Wallet_lockKeysFile = _WOWNERO_Wallet_lockKeysFilePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_unlockKeysFile(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_unlockKeysFile(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_unlockKeysFilePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_unlockKeysFile');
+  late final _WOWNERO_Wallet_unlockKeysFile = _WOWNERO_Wallet_unlockKeysFilePtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_Wallet_isKeysFileLocked(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_isKeysFileLocked(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_isKeysFileLockedPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_isKeysFileLocked');
+  late final _WOWNERO_Wallet_isKeysFileLocked =
+      _WOWNERO_Wallet_isKeysFileLockedPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_getDeviceType(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getDeviceType(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getDeviceTypePtr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_getDeviceType');
+  late final _WOWNERO_Wallet_getDeviceType = _WOWNERO_Wallet_getDeviceTypePtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_coldKeyImageSync(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int spent,
+    int unspent,
+  ) {
+    return _WOWNERO_Wallet_coldKeyImageSync(
+      wallet_ptr,
+      spent,
+      unspent,
+    );
+  }
+
+  late final _WOWNERO_Wallet_coldKeyImageSyncPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Uint64 Function(ffi.Pointer<ffi.Void>, ffi.Uint64,
+              ffi.Uint64)>>('WOWNERO_Wallet_coldKeyImageSync');
+  late final _WOWNERO_Wallet_coldKeyImageSync =
+      _WOWNERO_Wallet_coldKeyImageSyncPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_Wallet_deviceShowAddress(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    int accountIndex,
+    int addressIndex,
+  ) {
+    return _WOWNERO_Wallet_deviceShowAddress(
+      wallet_ptr,
+      accountIndex,
+      addressIndex,
+    );
+  }
+
+  late final _WOWNERO_Wallet_deviceShowAddressPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, ffi.Uint32,
+              ffi.Uint32)>>('WOWNERO_Wallet_deviceShowAddress');
+  late final _WOWNERO_Wallet_deviceShowAddress =
+      _WOWNERO_Wallet_deviceShowAddressPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>, int, int)>();
+
+  bool WOWNERO_Wallet_reconnectDevice(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_reconnectDevice(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_reconnectDevicePtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_reconnectDevice');
+  late final _WOWNERO_Wallet_reconnectDevice =
+      _WOWNERO_Wallet_reconnectDevicePtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_getBytesReceived(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getBytesReceived(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getBytesReceivedPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_getBytesReceived');
+  late final _WOWNERO_Wallet_getBytesReceived =
+      _WOWNERO_Wallet_getBytesReceivedPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_Wallet_getBytesSent(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_Wallet_getBytesSent(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_Wallet_getBytesSentPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_Wallet_getBytesSent');
+  late final _WOWNERO_Wallet_getBytesSent = _WOWNERO_Wallet_getBytesSentPtr
+      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_createWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int networkType,
+  ) {
+    return _WOWNERO_WalletManager_createWallet(
+      wm_ptr,
+      path,
+      password,
+      language,
+      networkType,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_createWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int)>>('WOWNERO_WalletManager_createWallet');
+  late final _WOWNERO_WalletManager_createWallet =
+      _WOWNERO_WalletManager_createWalletPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_openWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    int networkType,
+  ) {
+    return _WOWNERO_WalletManager_openWallet(
+      wm_ptr,
+      path,
+      password,
+      networkType,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_openWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int)>>('WOWNERO_WalletManager_openWallet');
+  late final _WOWNERO_WalletManager_openWallet =
+      _WOWNERO_WalletManager_openWalletPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_recoveryWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> mnemonic,
+    int networkType,
+    int restoreHeight,
+    int kdfRounds,
+    ffi.Pointer<ffi.Char> seedOffset,
+  ) {
+    return _WOWNERO_WalletManager_recoveryWallet(
+      wm_ptr,
+      path,
+      password,
+      mnemonic,
+      networkType,
+      restoreHeight,
+      kdfRounds,
+      seedOffset,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_recoveryWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Uint64,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_recoveryWallet');
+  late final _WOWNERO_WalletManager_recoveryWallet =
+      _WOWNERO_WalletManager_recoveryWalletPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_createWalletFromKeys(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int nettype,
+    int restoreHeight,
+    ffi.Pointer<ffi.Char> addressString,
+    ffi.Pointer<ffi.Char> viewKeyString,
+    ffi.Pointer<ffi.Char> spendKeyString,
+    int kdf_rounds,
+  ) {
+    return _WOWNERO_WalletManager_createWalletFromKeys(
+      wm_ptr,
+      path,
+      password,
+      language,
+      nettype,
+      restoreHeight,
+      addressString,
+      viewKeyString,
+      spendKeyString,
+      kdf_rounds,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_createWalletFromKeysPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Uint64,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint64)>>('WOWNERO_WalletManager_createWalletFromKeys');
+  late final _WOWNERO_WalletManager_createWalletFromKeys =
+      _WOWNERO_WalletManager_createWalletFromKeysPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int)>();
+
+  ffi.Pointer<ffi.Void>
+      WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int nettype,
+    int restoreHeight,
+    ffi.Pointer<ffi.Char> spendKeyString,
+    int kdf_rounds,
+  ) {
+    return _WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(
+      wm_ptr,
+      path,
+      password,
+      language,
+      nettype,
+      restoreHeight,
+      spendKeyString,
+      kdf_rounds,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_createDeterministicWalletFromSpendKeyPtr =
+      _lookup<
+              ffi.NativeFunction<
+                  ffi.Pointer<ffi.Void> Function(
+                      ffi.Pointer<ffi.Void>,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Int,
+                      ffi.Uint64,
+                      ffi.Pointer<ffi.Char>,
+                      ffi.Uint64)>>(
+          'WOWNERO_WalletManager_createDeterministicWalletFromSpendKey');
+  late final _WOWNERO_WalletManager_createDeterministicWalletFromSpendKey =
+      _WOWNERO_WalletManager_createDeterministicWalletFromSpendKeyPtr
+          .asFunction<
+              ffi.Pointer<ffi.Void> Function(
+                  ffi.Pointer<ffi.Void>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  ffi.Pointer<ffi.Char>,
+                  int,
+                  int,
+                  ffi.Pointer<ffi.Char>,
+                  int)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_WalletManager_createWalletFromPolyseed(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    int nettype,
+    ffi.Pointer<ffi.Char> mnemonic,
+    ffi.Pointer<ffi.Char> passphrase,
+    bool newWallet,
+    int restore_height,
+    int kdf_rounds,
+  ) {
+    return _WOWNERO_WalletManager_createWalletFromPolyseed(
+      wm_ptr,
+      path,
+      password,
+      nettype,
+      mnemonic,
+      passphrase,
+      newWallet,
+      restore_height,
+      kdf_rounds,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_createWalletFromPolyseedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Uint64,
+              ffi.Uint64)>>('WOWNERO_WalletManager_createWalletFromPolyseed');
+  late final _WOWNERO_WalletManager_createWalletFromPolyseed =
+      _WOWNERO_WalletManager_createWalletFromPolyseedPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              int,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              bool,
+              int,
+              int)>();
+
+  bool WOWNERO_WalletManager_closeWallet(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Void> wallet_ptr,
+    bool store,
+  ) {
+    return _WOWNERO_WalletManager_closeWallet(
+      wm_ptr,
+      wallet_ptr,
+      store,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_closeWalletPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>,
+              ffi.Bool)>>('WOWNERO_WalletManager_closeWallet');
+  late final _WOWNERO_WalletManager_closeWallet =
+      _WOWNERO_WalletManager_closeWalletPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Void>, bool)>();
+
+  bool WOWNERO_WalletManager_walletExists(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+  ) {
+    return _WOWNERO_WalletManager_walletExists(
+      wm_ptr,
+      path,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_walletExistsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_walletExists');
+  late final _WOWNERO_WalletManager_walletExists =
+      _WOWNERO_WalletManager_walletExistsPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  bool WOWNERO_WalletManager_verifyWalletPassword(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> keys_file_name,
+    ffi.Pointer<ffi.Char> password,
+    bool no_spend_key,
+    int kdf_rounds,
+  ) {
+    return _WOWNERO_WalletManager_verifyWalletPassword(
+      wm_ptr,
+      keys_file_name,
+      password,
+      no_spend_key,
+      kdf_rounds,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_verifyWalletPasswordPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool,
+              ffi.Uint64)>>('WOWNERO_WalletManager_verifyWalletPassword');
+  late final _WOWNERO_WalletManager_verifyWalletPassword =
+      _WOWNERO_WalletManager_verifyWalletPasswordPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, bool, int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_WalletManager_findWallets(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> separator,
+  ) {
+    return _WOWNERO_WalletManager_findWallets(
+      wm_ptr,
+      path,
+      separator,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_findWalletsPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_findWallets');
+  late final _WOWNERO_WalletManager_findWallets =
+      _WOWNERO_WalletManager_findWalletsPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_WalletManager_errorString(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_errorString(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_errorStringPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_WalletManager_errorString');
+  late final _WOWNERO_WalletManager_errorString =
+      _WOWNERO_WalletManager_errorStringPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_WalletManager_setDaemonAddress(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _WOWNERO_WalletManager_setDaemonAddress(
+      wm_ptr,
+      address,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_setDaemonAddressPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>>(
+      'WOWNERO_WalletManager_setDaemonAddress');
+  late final _WOWNERO_WalletManager_setDaemonAddress =
+      _WOWNERO_WalletManager_setDaemonAddressPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  int WOWNERO_WalletManager_blockchainHeight(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_blockchainHeight(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_blockchainHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_WalletManager_blockchainHeight');
+  late final _WOWNERO_WalletManager_blockchainHeight =
+      _WOWNERO_WalletManager_blockchainHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_WalletManager_blockchainTargetHeight(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_blockchainTargetHeight(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_blockchainTargetHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_WalletManager_blockchainTargetHeight');
+  late final _WOWNERO_WalletManager_blockchainTargetHeight =
+      _WOWNERO_WalletManager_blockchainTargetHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_WalletManager_networkDifficulty(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_networkDifficulty(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_networkDifficultyPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_WalletManager_networkDifficulty');
+  late final _WOWNERO_WalletManager_networkDifficulty =
+      _WOWNERO_WalletManager_networkDifficultyPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  double WOWNERO_WalletManager_miningHashRate(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_miningHashRate(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_miningHashRatePtr =
+      _lookup<ffi.NativeFunction<ffi.Double Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_WalletManager_miningHashRate');
+  late final _WOWNERO_WalletManager_miningHashRate =
+      _WOWNERO_WalletManager_miningHashRatePtr.asFunction<
+          double Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_WalletManager_blockTarget(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_blockTarget(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_blockTargetPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_WalletManager_blockTarget');
+  late final _WOWNERO_WalletManager_blockTarget =
+      _WOWNERO_WalletManager_blockTargetPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_WalletManager_isMining(
+    ffi.Pointer<ffi.Void> wm_ptr,
+  ) {
+    return _WOWNERO_WalletManager_isMining(
+      wm_ptr,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_isMiningPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_WalletManager_isMining');
+  late final _WOWNERO_WalletManager_isMining =
+      _WOWNERO_WalletManager_isMiningPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_WalletManager_startMining(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+    int threads,
+    bool backgroundMining,
+    bool ignoreBattery,
+  ) {
+    return _WOWNERO_WalletManager_startMining(
+      wm_ptr,
+      address,
+      threads,
+      backgroundMining,
+      ignoreBattery,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_startMiningPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Uint32,
+              ffi.Bool,
+              ffi.Bool)>>('WOWNERO_WalletManager_startMining');
+  late final _WOWNERO_WalletManager_startMining =
+      _WOWNERO_WalletManager_startMiningPtr.asFunction<
+          bool Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, int, bool, bool)>();
+
+  bool WOWNERO_WalletManager_stopMining(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _WOWNERO_WalletManager_stopMining(
+      wm_ptr,
+      address,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_stopMiningPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_stopMining');
+  late final _WOWNERO_WalletManager_stopMining =
+      _WOWNERO_WalletManager_stopMiningPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_WalletManager_resolveOpenAlias(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+    bool dnssec_valid,
+  ) {
+    return _WOWNERO_WalletManager_resolveOpenAlias(
+      wm_ptr,
+      address,
+      dnssec_valid,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_resolveOpenAliasPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Bool)>>('WOWNERO_WalletManager_resolveOpenAlias');
+  late final _WOWNERO_WalletManager_resolveOpenAlias =
+      _WOWNERO_WalletManager_resolveOpenAliasPtr.asFunction<
+          ffi.Pointer<ffi.Char> Function(
+              ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>, bool)>();
+
+  bool WOWNERO_WalletManager_setProxy(
+    ffi.Pointer<ffi.Void> wm_ptr,
+    ffi.Pointer<ffi.Char> address,
+  ) {
+    return _WOWNERO_WalletManager_setProxy(
+      wm_ptr,
+      address,
+    );
+  }
+
+  late final _WOWNERO_WalletManager_setProxyPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Bool Function(ffi.Pointer<ffi.Void>,
+              ffi.Pointer<ffi.Char>)>>('WOWNERO_WalletManager_setProxy');
+  late final _WOWNERO_WalletManager_setProxy =
+      _WOWNERO_WalletManager_setProxyPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>, ffi.Pointer<ffi.Char>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_WalletManagerFactory_getWalletManager() {
+    return _WOWNERO_WalletManagerFactory_getWalletManager();
+  }
+
+  late final _WOWNERO_WalletManagerFactory_getWalletManagerPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function()>>(
+          'WOWNERO_WalletManagerFactory_getWalletManager');
+  late final _WOWNERO_WalletManagerFactory_getWalletManager =
+      _WOWNERO_WalletManagerFactory_getWalletManagerPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function()>();
+
+  void WOWNERO_WalletManagerFactory_setLogLevel(
+    int level,
+  ) {
+    return _WOWNERO_WalletManagerFactory_setLogLevel(
+      level,
+    );
+  }
+
+  late final _WOWNERO_WalletManagerFactory_setLogLevelPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Int)>>(
+          'WOWNERO_WalletManagerFactory_setLogLevel');
+  late final _WOWNERO_WalletManagerFactory_setLogLevel =
+      _WOWNERO_WalletManagerFactory_setLogLevelPtr.asFunction<
+          void Function(int)>();
+
+  void WOWNERO_WalletManagerFactory_setLogCategories(
+    ffi.Pointer<ffi.Char> categories,
+  ) {
+    return _WOWNERO_WalletManagerFactory_setLogCategories(
+      categories,
+    );
+  }
+
+  late final _WOWNERO_WalletManagerFactory_setLogCategoriesPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Char>)>>(
+          'WOWNERO_WalletManagerFactory_setLogCategories');
+  late final _WOWNERO_WalletManagerFactory_setLogCategories =
+      _WOWNERO_WalletManagerFactory_setLogCategoriesPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_DEBUG_test0() {
+    return _WOWNERO_DEBUG_test0();
+  }
+
+  late final _WOWNERO_DEBUG_test0Ptr =
+      _lookup<ffi.NativeFunction<ffi.Void Function()>>('WOWNERO_DEBUG_test0');
+  late final _WOWNERO_DEBUG_test0 =
+      _WOWNERO_DEBUG_test0Ptr.asFunction<void Function()>();
+
+  bool WOWNERO_DEBUG_test1(
+    bool x,
+  ) {
+    return _WOWNERO_DEBUG_test1(
+      x,
+    );
+  }
+
+  late final _WOWNERO_DEBUG_test1Ptr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Bool)>>(
+          'WOWNERO_DEBUG_test1');
+  late final _WOWNERO_DEBUG_test1 =
+      _WOWNERO_DEBUG_test1Ptr.asFunction<bool Function(bool)>();
+
+  int WOWNERO_DEBUG_test2(
+    int x,
+  ) {
+    return _WOWNERO_DEBUG_test2(
+      x,
+    );
+  }
+
+  late final _WOWNERO_DEBUG_test2Ptr =
+      _lookup<ffi.NativeFunction<ffi.Int Function(ffi.Int)>>(
+          'WOWNERO_DEBUG_test2');
+  late final _WOWNERO_DEBUG_test2 =
+      _WOWNERO_DEBUG_test2Ptr.asFunction<int Function(int)>();
+
+  int WOWNERO_DEBUG_test3(
+    int x,
+  ) {
+    return _WOWNERO_DEBUG_test3(
+      x,
+    );
+  }
+
+  late final _WOWNERO_DEBUG_test3Ptr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Uint64)>>(
+          'WOWNERO_DEBUG_test3');
+  late final _WOWNERO_DEBUG_test3 =
+      _WOWNERO_DEBUG_test3Ptr.asFunction<int Function(int)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_DEBUG_test4(
+    int x,
+  ) {
+    return _WOWNERO_DEBUG_test4(
+      x,
+    );
+  }
+
+  late final _WOWNERO_DEBUG_test4Ptr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Void> Function(ffi.Uint64)>>(
+          'WOWNERO_DEBUG_test4');
+  late final _WOWNERO_DEBUG_test4 =
+      _WOWNERO_DEBUG_test4Ptr.asFunction<ffi.Pointer<ffi.Void> Function(int)>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_DEBUG_test5() {
+    return _WOWNERO_DEBUG_test5();
+  }
+
+  late final _WOWNERO_DEBUG_test5Ptr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
+          'WOWNERO_DEBUG_test5');
+  late final _WOWNERO_DEBUG_test5 =
+      _WOWNERO_DEBUG_test5Ptr.asFunction<ffi.Pointer<ffi.Char> Function()>();
+
+  ffi.Pointer<ffi.Char> WOWNERO_DEBUG_test5_std() {
+    return _WOWNERO_DEBUG_test5_std();
+  }
+
+  late final _WOWNERO_DEBUG_test5_stdPtr =
+      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Char> Function()>>(
+          'WOWNERO_DEBUG_test5_std');
+  late final _WOWNERO_DEBUG_test5_std = _WOWNERO_DEBUG_test5_stdPtr.asFunction<
+      ffi.Pointer<ffi.Char> Function()>();
+
+  bool WOWNERO_DEBUG_isPointerNull(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_DEBUG_isPointerNull(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_DEBUG_isPointerNullPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_DEBUG_isPointerNull');
+  late final _WOWNERO_DEBUG_isPointerNull = _WOWNERO_DEBUG_isPointerNullPtr
+      .asFunction<bool Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_cw_getWalletListener(
+    ffi.Pointer<ffi.Void> wallet_ptr,
+  ) {
+    return _WOWNERO_cw_getWalletListener(
+      wallet_ptr,
+    );
+  }
+
+  late final _WOWNERO_cw_getWalletListenerPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Void>)>>('WOWNERO_cw_getWalletListener');
+  late final _WOWNERO_cw_getWalletListener = _WOWNERO_cw_getWalletListenerPtr
+      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_cw_WalletListener_resetNeedToRefresh(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _WOWNERO_cw_WalletListener_resetNeedToRefresh(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _WOWNERO_cw_WalletListener_resetNeedToRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_cw_WalletListener_resetNeedToRefresh');
+  late final _WOWNERO_cw_WalletListener_resetNeedToRefresh =
+      _WOWNERO_cw_WalletListener_resetNeedToRefreshPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_cw_WalletListener_isNeedToRefresh(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _WOWNERO_cw_WalletListener_isNeedToRefresh(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _WOWNERO_cw_WalletListener_isNeedToRefreshPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_cw_WalletListener_isNeedToRefresh');
+  late final _WOWNERO_cw_WalletListener_isNeedToRefresh =
+      _WOWNERO_cw_WalletListener_isNeedToRefreshPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  bool WOWNERO_cw_WalletListener_isNewTransactionExist(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _WOWNERO_cw_WalletListener_isNewTransactionExist(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _WOWNERO_cw_WalletListener_isNewTransactionExistPtr =
+      _lookup<ffi.NativeFunction<ffi.Bool Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_cw_WalletListener_isNewTransactionExist');
+  late final _WOWNERO_cw_WalletListener_isNewTransactionExist =
+      _WOWNERO_cw_WalletListener_isNewTransactionExistPtr.asFunction<
+          bool Function(ffi.Pointer<ffi.Void>)>();
+
+  void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _WOWNERO_cw_WalletListener_resetIsNewTransactionExist(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _WOWNERO_cw_WalletListener_resetIsNewTransactionExistPtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_cw_WalletListener_resetIsNewTransactionExist');
+  late final _WOWNERO_cw_WalletListener_resetIsNewTransactionExist =
+      _WOWNERO_cw_WalletListener_resetIsNewTransactionExistPtr.asFunction<
+          void Function(ffi.Pointer<ffi.Void>)>();
+
+  int WOWNERO_cw_WalletListener_height(
+    ffi.Pointer<ffi.Void> cw_walletListener_ptr,
+  ) {
+    return _WOWNERO_cw_WalletListener_height(
+      cw_walletListener_ptr,
+    );
+  }
+
+  late final _WOWNERO_cw_WalletListener_heightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_cw_WalletListener_height');
+  late final _WOWNERO_cw_WalletListener_height =
+      _WOWNERO_cw_WalletListener_heightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Void>)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_deprecated_restore14WordSeed(
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> seed,
+    int networkType,
+  ) {
+    return _WOWNERO_deprecated_restore14WordSeed(
+      path,
+      password,
+      seed,
+      networkType,
+    );
+  }
+
+  late final _WOWNERO_deprecated_restore14WordSeedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int32)>>('WOWNERO_deprecated_restore14WordSeed');
+  late final _WOWNERO_deprecated_restore14WordSeed =
+      _WOWNERO_deprecated_restore14WordSeedPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();
+
+  ffi.Pointer<ffi.Void> WOWNERO_deprecated_create14WordSeed(
+    ffi.Pointer<ffi.Char> path,
+    ffi.Pointer<ffi.Char> password,
+    ffi.Pointer<ffi.Char> language,
+    int networkType,
+  ) {
+    return _WOWNERO_deprecated_create14WordSeed(
+      path,
+      password,
+      language,
+      networkType,
+    );
+  }
+
+  late final _WOWNERO_deprecated_create14WordSeedPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Pointer<ffi.Void> Function(
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>,
+              ffi.Int32)>>('WOWNERO_deprecated_create14WordSeed');
+  late final _WOWNERO_deprecated_create14WordSeed =
+      _WOWNERO_deprecated_create14WordSeedPtr.asFunction<
+          ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Char>,
+              ffi.Pointer<ffi.Char>, ffi.Pointer<ffi.Char>, int)>();
+
+  int WOWNERO_deprecated_14WordSeedHeight(
+    ffi.Pointer<ffi.Char> seed,
+  ) {
+    return _WOWNERO_deprecated_14WordSeedHeight(
+      seed,
+    );
+  }
+
+  late final _WOWNERO_deprecated_14WordSeedHeightPtr =
+      _lookup<ffi.NativeFunction<ffi.Uint64 Function(ffi.Pointer<ffi.Char>)>>(
+          'WOWNERO_deprecated_14WordSeedHeight');
+  late final _WOWNERO_deprecated_14WordSeedHeight =
+      _WOWNERO_deprecated_14WordSeedHeightPtr.asFunction<
+          int Function(ffi.Pointer<ffi.Char>)>();
+
+  void WOWNERO_free(
+    ffi.Pointer<ffi.Void> ptr,
+  ) {
+    return _WOWNERO_free(
+      ptr,
+    );
+  }
+
+  late final _WOWNERO_freePtr =
+      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
+          'WOWNERO_free');
+  late final _WOWNERO_free =
+      _WOWNERO_freePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();
+}
diff --git a/impls/monero.dart/lib/wownero.dart b/impls/monero.dart/lib/wownero.dart
new file mode 100644
index 0000000..2f9252d
--- /dev/null
+++ b/impls/monero.dart/lib/wownero.dart
@@ -0,0 +1,3614 @@
+library;
+
+// Are we memory safe?
+// There is a simple way to check that:
+// 1) Rewrite everything in rust
+// Or, assuming we are sane
+// 1) grep -E 'toNative|^String ' lib/wownero.dart | grep -v '^//' | grep -v '^String libPath = ' | wc -l
+//    This will print number of all things that produce pointers
+// 2) grep .free lib/wownero.dart | grep -v '^//' | wc -l
+//    This will print number of all free calls, these numbers should match
+
+// Wrapper around generated_bindings.g.dart - to provide easy access to the
+// underlying functions, feel free to not use it at all.
+
+//  _____________ PendingTransaction is just a typedef for Pointer<Void> (which is void* on C side)
+// /                   _____________ Wallet class, we didn't specify the MONERO prefix because we import the monero.dart code with monero prefix
+// |                  /       _____________ createTransaction function, from the upstream in the class Wallet
+// |                  |      /
+// PendingTransaction Wallet_createTransaction(wallet ptr, <------------- wallet is a typedef for Pointer<Void>
+//     {required String dst_addr,--------------------------------\ All of the parameters that are used in this function
+//     required String payment_id,                  _____________/ String - will get casted into const char*
+//     required int amount,                        /
+//     required int mixin_count,                  /                int - goes as it is
+//     required int pendingTransactionPriority,  /
+//     required int subaddr_account,            /
+//     List<String> preferredInputs = const []}) {                 List<String> - gets joined and passed as 2 separate parameters to be split in the C side____
+//   debugStart?.call('WOWNERO_Wallet_createTransaction'); <------------- debugStart functions just marks the function as currently being executed, used        |
+//   lib ??= WowneroC(DynamicLibrary.open(libPath));                    \_for performance debugging                                                             |
+//   \_____________ Load the library in case it is not loaded                                                                                                  |
+//   final dst_addr_ = dst_addr.toNativeUtf8().cast<Char>(); -----------------| Cast the strings into Chars so it can be used as a parameter in a function     |
+//   final payment_id_ = payment_id.toNativeUtf8().cast<Char>(); -------------| generated via ffigen                                                           |
+//   final preferredInputs_ = preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast<Char>(); <---------------------------------------------------------/
+//   final s = lib!.WOWNERO_Wallet_createTransaction(-------------|
+//     ptr,                                                       |
+//     dst_addr_,                                                 |
+//     payment_id_,                                               |
+//     amount,                                                    |
+//     mixin_count,                                               | Call the native function using generated code
+//     pendingTransactionPriority,                                |
+//     subaddr_account,                                           |
+//     preferredInputs_,                                          |
+//     defaultSeparator,                                          |
+//   );___________________________________________________________/
+//   calloc.free(dst_addr_);---------------| Free the memory once we don't need it
+//   calloc.free(payment_id_);-------------|
+//   debugEnd?.call('WOWNERO_Wallet_createTransaction'); <------------- Mark the function as executed
+//   return s; <------------- return the value
+// }
+//
+// Extra case is happening when we have a function call that returns const char* as we have to be memory safe
+// String PendingTransaction_txid(PendingTransaction ptr, String separator) {
+//   debugStart?.call('WOWNERO_PendingTransaction_txid');
+//   lib ??= WowneroC(DynamicLibrary.open(libPath));
+//   final separator_ = separator.toNativeUtf8().cast<Char>();
+//   final txid = lib!.WOWNERO_PendingTransaction_txid(ptr, separator_);
+//   calloc.free(separator_);
+//   debugEnd?.call('WOWNERO_PendingTransaction_txid');
+//   try { <------------- We need to try-catch these calls because they may fail in an unlikely case when we get an invalid UTF-8 string,
+//     final strPtr = txid.cast<Utf8>();                                            it is better to throw than to crash main isolate imo.
+//     final str = strPtr.toDartString(); <------------- convert the pointer to const char* to dart String
+//     WOWNERO_free(strPtr.cast()); <------------- free the memory
+//     debugEnd?.call('WOWNERO_PendingTransaction_txid');
+//     return str; <------------- return the value
+//   } catch (e) {
+//     errorHandler?.call('WOWNERO_PendingTransaction_txid', e);
+//     debugEnd?.call('WOWNERO_PendingTransaction_txid');
+//     return ""; <------------- return an empty string in case of an error.
+//   }
+// }
+//
+
+// ignore_for_file: non_constant_identifier_names, camel_case_types
+
+import 'dart:ffi';
+import 'dart:io';
+
+import 'package:ffi/ffi.dart';
+import 'package:monero/src/generated_bindings_wownero.g.dart';
+
+typedef PendingTransaction = Pointer<Void>;
+
+WowneroC? lib;
+String libPath = (() {
+  if (Platform.isWindows) return 'wownero_libwallet2_api_c.dll';
+  if (Platform.isMacOS) return 'wownero_libwallet2_api_c.dylib';
+  if (Platform.isIOS) return 'WowneroWallet.framework/WowneroWallet';
+  if (Platform.isAndroid) return 'libwownero_libwallet2_api_c.so';
+  return 'wownero_libwallet2_api_c.so';
+})();
+
+Map<String, List<int>> debugCallLength = {};
+
+final defaultSeparatorStr = ";";
+final defaultSeparator = defaultSeparatorStr.toNativeUtf8().cast<Char>();
+/* we don't call .free here, this comment serves one purpose - so the numbers match :) */
+
+final Stopwatch sw = Stopwatch()..start();
+
+bool printStarts = false;
+
+void Function(String call)? debugStart = (call) {
+  if (printStarts) print("MONERO: $call");
+  debugCallLength[call] ??= <int>[];
+  debugCallLength[call]!.add(sw.elapsedMicroseconds);
+};
+void Function(String call)? debugEnd = (call) {
+  final id = debugCallLength[call]!.length - 1;
+  debugCallLength[call]![id] =
+      sw.elapsedMicroseconds - debugCallLength[call]![id];
+};
+void Function(String call, dynamic error)? errorHandler = (call, error) {
+  print("$call: $error");
+};
+
+int PendingTransaction_status(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_status');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_PendingTransaction_status(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_status');
+  return status;
+}
+
+String PendingTransaction_errorString(PendingTransaction ptr) {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  debugStart?.call('WOWNERO_PendingTransaction_errorString');
+  try {
+    final rPtr = lib!.WOWNERO_PendingTransaction_errorString(ptr).cast<Utf8>();
+    final str = rPtr.toDartString();
+    WOWNERO_free(rPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_errorString', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_errorString');
+    return "";
+  }
+}
+
+bool PendingTransaction_commit(PendingTransaction ptr,
+    {required String filename, required bool overwrite}) {
+  debugStart?.call('WOWNERO_PendingTransaction_commit');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final result =
+      lib!.WOWNERO_PendingTransaction_commit(ptr, filename_, overwrite);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_PendingTransaction_commit');
+  return result;
+}
+
+int PendingTransaction_amount(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final amount = lib!.WOWNERO_PendingTransaction_amount(ptr);
+  debugStart?.call('WOWNERO_PendingTransaction_amount');
+  return amount;
+}
+
+int PendingTransaction_dust(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_dust');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dust = lib!.WOWNERO_PendingTransaction_dust(ptr);
+  debugStart?.call('WOWNERO_PendingTransaction_dust');
+  return dust;
+}
+
+int PendingTransaction_fee(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_fee');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final fee = lib!.WOWNERO_PendingTransaction_fee(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_fee');
+  return fee;
+}
+
+String PendingTransaction_txid(PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_txid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_txid(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_txid');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_txid');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_txid', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_txid');
+    return "";
+  }
+}
+
+int PendingTransaction_txCount(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_txCount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txCount = lib!.WOWNERO_PendingTransaction_txCount(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_txCount');
+  return txCount;
+}
+
+String PendingTransaction_subaddrAccount(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_subaddrAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_subaddrAccount(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_subaddrAccount', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount');
+    return "";
+  }
+}
+
+String PendingTransaction_subaddrIndices(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_subaddrIndices');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_subaddrIndices(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_subaddrIndices', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices');
+    return "";
+  }
+}
+
+String PendingTransaction_multisigSignData(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_multisigSignData');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid = lib!.WOWNERO_PendingTransaction_multisigSignData(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_multisigSignData');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_PendingTransaction_multisigSignData');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_multisigSignData', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_multisigSignData');
+    return "";
+  }
+}
+
+void PendingTransaction_signMultisigTx(PendingTransaction ptr) {
+  debugStart?.call('WOWNERO_PendingTransaction_signMultisigTx');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.WOWNERO_PendingTransaction_signMultisigTx(ptr);
+  debugEnd?.call('WOWNERO_PendingTransaction_signMultisigTx');
+  return ret;
+}
+
+String PendingTransaction_signersKeys(
+    PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_signersKeys');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_signersKeys(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_signersKeys');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    debugEnd?.call('WOWNERO_PendingTransaction_signersKeys');
+    WOWNERO_free(strPtr.cast());
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_signersKeys', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_signersKeys');
+    return "";
+  }
+}
+
+String PendingTransaction_hex(PendingTransaction ptr, String separator) {
+  debugStart?.call('WOWNERO_PendingTransaction_hex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final separator_ = separator.toNativeUtf8().cast<Char>();
+  final txid = lib!.WOWNERO_PendingTransaction_hex(ptr, separator_);
+  calloc.free(separator_);
+  debugEnd?.call('WOWNERO_PendingTransaction_hex');
+  try {
+    final strPtr = txid.cast<Utf8>();
+    final str = strPtr.toDartString();
+    debugEnd?.call('WOWNERO_PendingTransaction_hex');
+    WOWNERO_free(strPtr.cast());
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_PendingTransaction_hex', e);
+    debugEnd?.call('WOWNERO_PendingTransaction_hex');
+    return "";
+  }
+}
+
+// UnsignedTransaction
+
+typedef UnsignedTransaction = Pointer<Void>;
+
+int UnsignedTransaction_status(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_status');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dust = lib!.WOWNERO_UnsignedTransaction_status(ptr);
+  debugStart?.call('WOWNERO_UnsignedTransaction_status');
+  return dust;
+}
+
+String UnsignedTransaction_errorString(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_errorString');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString = lib!.WOWNERO_UnsignedTransaction_errorString(ptr);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_errorString', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_errorString');
+    return "";
+  }
+}
+
+String UnsignedTransaction_amount(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_amount');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_amount(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_amount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_amount', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_amount');
+    return "";
+  }
+}
+
+String UnsignedTransaction_fee(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_fee');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_fee(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_fee');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_fee', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_fee');
+    return "";
+  }
+}
+
+String UnsignedTransaction_mixin(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_mixin');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_mixin(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_mixin');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_mixin', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_mixin');
+    return "";
+  }
+}
+
+String UnsignedTransaction_confirmationMessage(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_confirmationMessage');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString = lib!.WOWNERO_UnsignedTransaction_confirmationMessage(ptr);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_confirmationMessage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_confirmationMessage', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_confirmationMessage');
+    return "";
+  }
+}
+
+String UnsignedTransaction_paymentId(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_paymentId');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_paymentId(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_paymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_paymentId', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_paymentId');
+    return "";
+  }
+}
+
+String UnsignedTransaction_recipientAddress(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_recipientAddress');
+
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final errorString =
+      lib!.WOWNERO_UnsignedTransaction_recipientAddress(ptr, defaultSeparator);
+  try {
+    final strPtr = errorString.cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_UnsignedTransaction_recipientAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_UnsignedTransaction_recipientAddress', e);
+    debugEnd?.call('WOWNERO_UnsignedTransaction_recipientAddress');
+    return "";
+  }
+}
+
+int UnsignedTransaction_minMixinCount(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_minMixinCount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_UnsignedTransaction_minMixinCount(ptr);
+  debugStart?.call('WOWNERO_UnsignedTransaction_minMixinCount');
+  return v;
+}
+
+int UnsignedTransaction_txCount(UnsignedTransaction ptr) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_txCount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_UnsignedTransaction_txCount(ptr);
+  debugStart?.call('WOWNERO_UnsignedTransaction_txCount');
+  return v;
+}
+
+bool UnsignedTransaction_sign(UnsignedTransaction ptr, String signedFileName) {
+  debugStart?.call('WOWNERO_UnsignedTransaction_sign');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final signedFileName_ = signedFileName.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_UnsignedTransaction_sign(ptr, signedFileName_);
+  calloc.free(signedFileName_);
+  debugStart?.call('WOWNERO_UnsignedTransaction_sign');
+  return v;
+}
+// TransactionInfo
+
+typedef TransactionInfo = Pointer<Void>;
+
+enum TransactionInfo_Direction { In, Out }
+
+TransactionInfo_Direction TransactionInfo_direction(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_direction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final tiDir = TransactionInfo_Direction
+      .values[lib!.WOWNERO_TransactionInfo_direction(ptr)];
+  debugEnd?.call('WOWNERO_TransactionInfo_direction');
+  return tiDir;
+}
+
+bool TransactionInfo_isPending(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_isPending');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isPending = lib!.WOWNERO_TransactionInfo_isPending(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_isPending');
+
+  return isPending;
+}
+
+bool TransactionInfo_isFailed(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_isFailed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isFailed = lib!.WOWNERO_TransactionInfo_isFailed(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_isFailed');
+  return isFailed;
+}
+
+bool TransactionInfo_isCoinbase(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_isCoinbase');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isCoinbase = lib!.WOWNERO_TransactionInfo_isCoinbase(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_isCoinbase');
+  return isCoinbase;
+}
+
+int TransactionInfo_amount(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final amount = lib!.WOWNERO_TransactionInfo_amount(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_amount');
+  return amount;
+}
+
+int TransactionInfo_fee(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_fee');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final fee = lib!.WOWNERO_TransactionInfo_fee(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_fee');
+  return fee;
+}
+
+int TransactionInfo_blockHeight(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_blockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final blockHeight = lib!.WOWNERO_TransactionInfo_blockHeight(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_blockHeight');
+  return blockHeight;
+}
+
+String TransactionInfo_description(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_description');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_description(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_description');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_description', e);
+    return "";
+  }
+}
+
+String TransactionInfo_subaddrIndex(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_subaddrIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_TransactionInfo_subaddrIndex(ptr, defaultSeparator)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_subaddrIndex');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_subaddrIndex', e);
+    return "";
+  }
+}
+
+int TransactionInfo_subaddrAccount(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_subaddrAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final subaddrAccount = lib!.WOWNERO_TransactionInfo_subaddrAccount(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_subaddrAccount');
+  return subaddrAccount;
+}
+
+String TransactionInfo_label(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_label');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_label(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_label');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_label', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_label');
+    return "";
+  }
+}
+
+int TransactionInfo_confirmations(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_confirmations');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final confirmations = lib!.WOWNERO_TransactionInfo_confirmations(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_confirmations');
+  return confirmations;
+}
+
+int TransactionInfo_unlockTime(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_unlockTime');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final unlockTime = lib!.WOWNERO_TransactionInfo_unlockTime(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_unlockTime');
+  return unlockTime;
+}
+
+String TransactionInfo_hash(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_hash');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_hash(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_hash');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_hash', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_hash');
+    return "";
+  }
+}
+
+int TransactionInfo_timestamp(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_timestamp');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final timestamp = lib!.WOWNERO_TransactionInfo_timestamp(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_timestamp');
+  return timestamp;
+}
+
+String TransactionInfo_paymentId(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_paymentId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_TransactionInfo_paymentId(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_paymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_paymentId', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_paymentId');
+    return "";
+  }
+}
+
+int TransactionInfo_transfers_count(TransactionInfo ptr) {
+  debugStart?.call('WOWNERO_TransactionInfo_transfers_count');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_TransactionInfo_transfers_count(ptr);
+  debugEnd?.call('WOWNERO_TransactionInfo_transfers_count');
+  return v;
+}
+
+int TransactionInfo_transfers_amount(TransactionInfo ptr, int index) {
+  debugStart?.call('WOWNERO_TransactionInfo_transfers_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_TransactionInfo_transfers_amount(ptr, index);
+  debugEnd?.call('WOWNERO_TransactionInfo_transfers_amount');
+  return v;
+}
+
+String TransactionInfo_transfers_address(TransactionInfo ptr, int index) {
+  debugStart?.call('WOWNERO_TransactionInfo_transfers_address');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_TransactionInfo_transfers_address(ptr, index).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_TransactionInfo_transfers_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_TransactionInfo_transfers_address', e);
+    debugEnd?.call('WOWNERO_TransactionInfo_transfers_address');
+    return "";
+  }
+}
+
+// TransactionHistory
+
+typedef TransactionHistory = Pointer<Void>;
+
+int TransactionHistory_count(TransactionHistory txHistory_ptr) {
+  debugStart?.call('WOWNERO_TransactionHistory_count');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final count = lib!.WOWNERO_TransactionHistory_count(txHistory_ptr);
+  debugEnd?.call('WOWNERO_TransactionHistory_count');
+  return count;
+}
+
+TransactionInfo TransactionHistory_transaction(TransactionHistory txHistory_ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_TransactionHistory_transaction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final transaction =
+      lib!.WOWNERO_TransactionHistory_transaction(txHistory_ptr, index);
+  debugEnd?.call('WOWNERO_TransactionHistory_transaction');
+  return transaction;
+}
+
+TransactionInfo TransactionHistory_transactionById(
+    TransactionHistory txHistory_ptr,
+    {required String txid}) {
+  debugStart?.call('WOWNERO_TransactionHistory_transactionById');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final transaction =
+      lib!.WOWNERO_TransactionHistory_transactionById(txHistory_ptr, txid_);
+  calloc.free(txid_);
+  debugEnd?.call('WOWNERO_TransactionHistory_transactionById');
+  return transaction;
+}
+
+void TransactionHistory_refresh(TransactionHistory txHistory_ptr) {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  return lib!.WOWNERO_TransactionHistory_refresh(txHistory_ptr);
+}
+
+void TransactionHistory_setTxNote(TransactionHistory txHistory_ptr,
+    {required String txid, required String note}) {
+  debugStart?.call('WOWNERO_TransactionHistory_setTxNote');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final note_ = note.toNativeUtf8().cast<Char>();
+  final s =
+      lib!.WOWNERO_TransactionHistory_setTxNote(txHistory_ptr, txid_, note_);
+  calloc.free(txid_);
+  calloc.free(note_);
+  debugEnd?.call('WOWNERO_TransactionHistory_setTxNote');
+  return s;
+}
+
+// AddresBookRow
+
+typedef AddressBookRow = Pointer<Void>;
+
+String AddressBookRow_extra(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_extra');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_AddressBookRow_extra(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_extra', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_extra');
+    return "";
+  }
+}
+
+String AddressBookRow_getAddress(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_AddressBookRow_getAddress(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_getAddress', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_getAddress');
+    return "";
+  }
+}
+
+String AddressBookRow_getDescription(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getDescription');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_AddressBookRow_getDescription(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_getDescription');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_getDescription', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_getDescription');
+    return "";
+  }
+}
+
+String AddressBookRow_getPaymentId(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getPaymentId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_AddressBookRow_getPaymentId(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_AddressBookRow_getPaymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_AddressBookRow_getPaymentId', e);
+    debugEnd?.call('WOWNERO_AddressBookRow_getPaymentId');
+    return "";
+  }
+}
+
+int AddressBookRow_getRowId(AddressBookRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_AddressBookRow_getRowId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBookRow_getRowId(addressBookRow_ptr);
+  debugEnd?.call('WOWNERO_AddressBookRow_getRowId');
+  return v;
+}
+
+// AddressBook
+
+typedef AddressBook = Pointer<Void>;
+
+int AddressBook_getAll_size(AddressBook addressBook_ptr) {
+  debugStart?.call('WOWNERO_AddressBook_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_getAll_size(addressBook_ptr);
+  debugEnd?.call('WOWNERO_AddressBook_getAll_size');
+  return v;
+}
+
+AddressBookRow AddressBook_getAll_byIndex(AddressBook addressBook_ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_AddressBook_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_getAll_byIndex(addressBook_ptr, index);
+  debugEnd?.call('WOWNERO_AddressBook_getAll_byIndex');
+  return v;
+}
+
+bool AddressBook_addRow(
+  AddressBook addressBook_ptr, {
+  required String dstAddr,
+  required String paymentId,
+  required String description,
+}) {
+  debugStart?.call('WOWNERO_AddressBook_addRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dst_addr_ = dstAddr.toNativeUtf8().cast<Char>();
+  final payment_id_ = paymentId.toNativeUtf8().cast<Char>();
+  final description_ = description.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_AddressBook_addRow(
+      addressBook_ptr, dst_addr_, payment_id_, description_);
+  calloc.free(dst_addr_);
+  calloc.free(payment_id_);
+  calloc.free(description_);
+  debugEnd?.call('WOWNERO_AddressBook_addRow');
+  return v;
+}
+
+bool AddressBook_deleteRow(AddressBook addressBook_ptr, {required int rowId}) {
+  debugStart?.call('WOWNERO_AddressBook_deleteRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_deleteRow(addressBook_ptr, rowId);
+  debugEnd?.call('WOWNERO_AddressBook_deleteRow');
+  return v;
+}
+
+bool AddressBook_setDescription(
+  AddressBook addressBook_ptr, {
+  required int rowId,
+  required String description,
+}) {
+  debugStart?.call('WOWNERO_AddressBook_setDescription');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final description_ = description.toNativeUtf8().cast<Char>();
+  final v = lib!
+      .WOWNERO_AddressBook_setDescription(addressBook_ptr, rowId, description_);
+  calloc.free(description_);
+  debugEnd?.call('WOWNERO_AddressBook_setDescription');
+  return v;
+}
+
+void AddressBook_refresh(AddressBook addressBook_ptr) {
+  debugStart?.call('WOWNERO_AddressBook_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_refresh(addressBook_ptr);
+  debugEnd?.call('WOWNERO_AddressBook_refresh');
+  return v;
+}
+
+int AddressBook_errorCode(AddressBook addressBook_ptr) {
+  debugStart?.call('WOWNERO_AddressBook_errorCode');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_AddressBook_errorCode(addressBook_ptr);
+  debugEnd?.call('WOWNERO_AddressBook_errorCode');
+  return v;
+}
+
+int AddressBook_lookupPaymentID(AddressBook addressBook_ptr,
+    {required String paymentId}) {
+  debugStart?.call('WOWNERO_AddressBook_lookupPaymentID');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+  final v =
+      lib!.WOWNERO_AddressBook_lookupPaymentID(addressBook_ptr, paymentId_);
+  calloc.free(paymentId_);
+  debugEnd?.call('WOWNERO_AddressBook_lookupPaymentID');
+  return v;
+}
+
+// CoinsInfo
+typedef CoinsInfo = Pointer<Void>;
+
+int CoinsInfo_blockHeight(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_blockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_blockHeight(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_blockHeight');
+  return v;
+}
+
+String CoinsInfo_hash(CoinsInfo addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_hash');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_CoinsInfo_hash(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_hash');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_hash', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_hash');
+    return "";
+  }
+}
+
+int CoinsInfo_internalOutputIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_internalOutputIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_internalOutputIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_internalOutputIndex');
+  return v;
+}
+
+int CoinsInfo_globalOutputIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_globalOutputIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_globalOutputIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_globalOutputIndex');
+  return v;
+}
+
+bool CoinsInfo_spent(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_spent');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_spent(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_spent');
+  return v;
+}
+
+bool CoinsInfo_frozen(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_frozen');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_frozen(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_frozen');
+  return v;
+}
+
+int CoinsInfo_spentHeight(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_spentHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_spentHeight(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_spentHeight');
+  return v;
+}
+
+int CoinsInfo_amount(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_amount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_amount(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_amount');
+  return v;
+}
+
+bool CoinsInfo_rct(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_rct');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_rct(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_rct');
+  return v;
+}
+
+bool CoinsInfo_keyImageKnown(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_keyImageKnown');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_keyImageKnown(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_keyImageKnown');
+  return v;
+}
+
+int CoinsInfo_pkIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_pkIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_pkIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_pkIndex');
+  return v;
+}
+
+int CoinsInfo_subaddrIndex(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_subaddrIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_subaddrIndex(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_subaddrIndex');
+  return v;
+}
+
+int CoinsInfo_subaddrAccount(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_subaddrAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_subaddrAccount(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_subaddrAccount');
+  return v;
+}
+
+String CoinsInfo_address(CoinsInfo addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_address');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_CoinsInfo_address(addressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_address', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_address');
+    return "";
+  }
+}
+
+String CoinsInfo_addressLabel(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_addressLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_CoinsInfo_addressLabel(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_addressLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_addressLabel', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_addressLabel');
+    return "";
+  }
+}
+
+String CoinsInfo_keyImage(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_keyImage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_CoinsInfo_keyImage(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_keyImage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_keyImage', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_keyImage');
+    return "";
+  }
+}
+
+int CoinsInfo_unlockTime(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_unlockTime');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_unlockTime(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_unlockTime');
+  return v;
+}
+
+bool CoinsInfo_unlocked(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_unlocked');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_unlocked(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_unlocked');
+  return v;
+}
+
+String CoinsInfo_pubKey(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_pubKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_CoinsInfo_pubKey(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_pubKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_pubKey', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_pubKey');
+    return "";
+  }
+}
+
+bool CoinsInfo_coinbase(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_coinbase');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_CoinsInfo_coinbase(coinsInfo_ptr);
+  debugEnd?.call('WOWNERO_CoinsInfo_coinbase');
+  return v;
+}
+
+String CoinsInfo_description(CoinsInfo coinsInfo_ptr) {
+  debugStart?.call('WOWNERO_CoinsInfo_description');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_CoinsInfo_description(coinsInfo_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_CoinsInfo_description');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_CoinsInfo_description', e);
+    debugEnd?.call('WOWNERO_CoinsInfo_description');
+    return "";
+  }
+}
+
+typedef Coins = Pointer<Void>;
+
+int Coins_count(Coins coins_ptr) {
+  debugStart?.call('WOWNERO_Coins_count');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_count(coins_ptr);
+  debugEnd?.call('WOWNERO_Coins_count');
+  return v;
+}
+
+CoinsInfo Coins_coin(Coins coins_ptr, int index) {
+  debugStart?.call('WOWNERO_Coins_coin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_coin(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_coin');
+  return v;
+}
+
+int Coins_getAll_size(Coins coins_ptr) {
+  debugStart?.call('WOWNERO_Coins_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_getAll_size(coins_ptr);
+  debugEnd?.call('WOWNERO_Coins_getAll_size');
+  return v;
+}
+
+CoinsInfo Coins_getAll_byIndex(Coins coins_ptr, int index) {
+  debugStart?.call('WOWNERO_Coins_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_getAll_byIndex(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_getAll_byIndex');
+  return v;
+}
+
+void Coins_refresh(Coins coins_ptr) {
+  debugStart?.call('WOWNERO_Coins_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_refresh(coins_ptr);
+  debugEnd?.call('WOWNERO_Coins_refresh');
+  return v;
+}
+
+void Coins_setFrozenByPublicKey(Coins coins_ptr, {required String publicKey}) {
+  debugStart?.call('WOWNERO_Coins_setFrozenByPublicKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final publicKey_ = publicKey.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Coins_setFrozenByPublicKey(coins_ptr, publicKey_);
+  calloc.free(publicKey_);
+  debugEnd?.call('WOWNERO_Coins_setFrozenByPublicKey');
+  return v;
+}
+
+void Coins_setFrozen(Coins coins_ptr, {required int index}) {
+  debugStart?.call('WOWNERO_Coins_setFrozen');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_setFrozen(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_setFrozen');
+  return v;
+}
+
+void Coins_thaw(Coins coins_ptr, {required int index}) {
+  debugStart?.call('WOWNERO_Coins_thaw');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Coins_thaw(coins_ptr, index);
+  debugEnd?.call('WOWNERO_Coins_thaw');
+  return v;
+}
+
+void Coins_thawByPublicKey(Coins coins_ptr, {required String publicKey}) {
+  debugStart?.call('WOWNERO_Coins_thawByPublicKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final publicKey_ = publicKey.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Coins_thawByPublicKey(coins_ptr, publicKey_);
+  calloc.free(publicKey_);
+  debugEnd?.call('WOWNERO_Coins_thawByPublicKey');
+  return v;
+}
+
+bool Coins_isTransferUnlocked(
+  Coins coins_ptr, {
+  required int unlockTime,
+  required int blockHeight,
+}) {
+  debugStart?.call('WOWNERO_Coins_isTransferUnlocked');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v =
+      lib!.WOWNERO_Coins_isTransferUnlocked(coins_ptr, unlockTime, blockHeight);
+  debugEnd?.call('WOWNERO_Coins_isTransferUnlocked');
+  return v;
+}
+
+// SubaddressRow
+
+typedef SubaddressRow = Pointer<Void>;
+
+String SubaddressRow_extra(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_extra');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_SubaddressRow_extra(subaddressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressRow_extra', e);
+    debugEnd?.call('WOWNERO_SubaddressRow_extra');
+    return "";
+  }
+}
+
+String SubaddressRow_getAddress(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_getAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressRow_getAddress(subaddressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressRow_getAddress', e);
+    debugEnd?.call('WOWNERO_SubaddressRow_getAddress');
+    return "";
+  }
+}
+
+String SubaddressRow_getLabel(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_getLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_SubaddressRow_getLabel(subaddressBookRow_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressRow_getLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressRow_getLabel', e);
+    debugEnd?.call('WOWNERO_SubaddressRow_getLabel');
+    return "";
+  }
+}
+
+int SubaddressRow_getRowId(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressRow_getRowId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressRow_getRowId(subaddressBookRow_ptr);
+  debugEnd?.call('WOWNERO_SubaddressRow_getRowId');
+  return status;
+}
+
+// Subaddress
+
+typedef Subaddress = Pointer<Void>;
+
+int Subaddress_getAll_size(SubaddressRow subaddressBookRow_ptr) {
+  debugStart?.call('WOWNERO_Subaddress_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Subaddress_getAll_size(subaddressBookRow_ptr);
+  debugEnd?.call('WOWNERO_Subaddress_getAll_size');
+  return status;
+}
+
+SubaddressRow Subaddress_getAll_byIndex(Subaddress subaddressRow_ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_Subaddress_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.WOWNERO_Subaddress_getAll_byIndex(subaddressRow_ptr, index);
+  debugEnd?.call('WOWNERO_Subaddress_getAll_byIndex');
+  return status;
+}
+
+void Subaddress_addRow(Subaddress ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('WOWNERO_Subaddress_addRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Subaddress_addRow(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Subaddress_addRow');
+  return status;
+}
+
+void Subaddress_setLabel(Subaddress ptr,
+    {required int accountIndex,
+    required int addressIndex,
+    required String label}) {
+  debugStart?.call('WOWNERO_Subaddress_setLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status =
+      lib!.WOWNERO_Subaddress_setLabel(ptr, accountIndex, addressIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Subaddress_setLabel');
+  return status;
+}
+
+void Subaddress_refresh(Subaddress ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('WOWNERO_Subaddress_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Subaddress_refresh(ptr, accountIndex);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Subaddress_refresh');
+  return status;
+}
+
+typedef SubaddressAccountRow = Pointer<Void>;
+
+String SubaddressAccountRow_extra(SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_extra');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_extra(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_extra');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_extra', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_extra');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getAddress(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getAddress(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getAddress', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getAddress');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getLabel(SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getLabel(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getLabel', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getLabel');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getBalance(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getBalance(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getBalance');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getBalance', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getBalance');
+    return "";
+  }
+}
+
+String SubaddressAccountRow_getUnlockedBalance(
+    SubaddressAccountRow addressBookRow_ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_SubaddressAccountRow_getUnlockedBalance(addressBookRow_ptr)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance', e);
+    debugEnd?.call('WOWNERO_SubaddressAccountRow_getUnlockedBalance');
+    return "";
+  }
+}
+
+int SubaddressAccountRow_getRowId(SubaddressAccountRow ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccountRow_getRowId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccountRow_getRowId(ptr);
+  debugEnd?.call('WOWNERO_SubaddressAccountRow_getRowId');
+  return status;
+}
+
+typedef SubaddressAccount = Pointer<Void>;
+
+int SubaddressAccount_getAll_size(SubaddressAccount ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccount_getAll_size');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccount_getAll_size(ptr);
+  debugEnd?.call('WOWNERO_SubaddressAccount_getAll_size');
+  return status;
+}
+
+SubaddressAccountRow SubaddressAccount_getAll_byIndex(SubaddressAccount ptr,
+    {required int index}) {
+  debugStart?.call('WOWNERO_SubaddressAccount_getAll_byIndex');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccount_getAll_byIndex(ptr, index);
+  debugEnd?.call('WOWNERO_SubaddressAccount_getAll_byIndex');
+  return status;
+}
+
+void SubaddressAccount_addRow(SubaddressAccount ptr, {required String label}) {
+  debugStart?.call('WOWNERO_SubaddressAccount_addRow');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_SubaddressAccount_addRow(ptr, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_SubaddressAccount_addRow');
+  return status;
+}
+
+void SubaddressAccount_setLabel(SubaddressAccount ptr,
+    {required int accountIndex, required String label}) {
+  debugStart?.call('WOWNERO_SubaddressAccount_setLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final status =
+      lib!.WOWNERO_SubaddressAccount_setLabel(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_SubaddressAccount_setLabel');
+  return status;
+}
+
+void SubaddressAccount_refresh(SubaddressAccount ptr) {
+  debugStart?.call('WOWNERO_SubaddressAccount_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_SubaddressAccount_refresh(ptr);
+  debugEnd?.call('WOWNERO_SubaddressAccount_refresh');
+  return status;
+}
+
+// MultisigState
+
+typedef MultisigState = Pointer<Void>;
+
+bool MultisigState_isMultisig(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_isMultisig');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_isMultisig(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_isMultisig');
+  return status;
+}
+
+bool MultisigState_isReady(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_isReady');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_isReady(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_isReady');
+  return status;
+}
+
+int MultisigState_threshold(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_threshold');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_threshold(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_threshold');
+  return status;
+}
+
+int MultisigState_total(MultisigState ptr) {
+  debugStart?.call('WOWNERO_MultisigState_total');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_MultisigState_total(ptr);
+  debugEnd?.call('WOWNERO_MultisigState_total');
+  return status;
+}
+
+// DeviceProgress
+
+typedef DeviceProgress = Pointer<Void>;
+
+bool DeviceProgress_progress(DeviceProgress ptr) {
+  debugStart?.call('WOWNERO_DeviceProgress_progress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_DeviceProgress_progress(ptr);
+  debugEnd?.call('WOWNERO_DeviceProgress_progress');
+  return status;
+}
+
+bool DeviceProgress_indeterminate(DeviceProgress ptr) {
+  debugStart?.call('WOWNERO_DeviceProgress_indeterminate');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_DeviceProgress_indeterminate(ptr);
+  debugEnd?.call('WOWNERO_DeviceProgress_indeterminate');
+  return status;
+}
+// Wallet
+
+typedef wallet = Pointer<Void>;
+
+String Wallet_seed(wallet ptr, {required String seedOffset}) {
+  debugStart?.call('WOWNERO_Wallet_seed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.WOWNERO_Wallet_seed(ptr, seedOffset_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(seedOffset_);
+    debugEnd?.call('WOWNERO_Wallet_seed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_seed', e);
+    debugEnd?.call('WOWNERO_Wallet_seed');
+    return "";
+  }
+}
+
+String Wallet_getSeedLanguage(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getSeedLanguage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_getSeedLanguage(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getSeedLanguage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getSeedLanguage', e);
+    debugEnd?.call('WOWNERO_Wallet_getSeedLanguage');
+    return "";
+  }
+}
+
+void Wallet_setSeedLanguage(wallet ptr, {required String language}) {
+  debugStart?.call('WOWNERO_Wallet_setSeedLanguage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Wallet_setSeedLanguage(ptr, language_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_Wallet_setSeedLanguage');
+  return status;
+}
+
+int Wallet_status(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_status');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_status(ptr);
+  debugEnd?.call('WOWNERO_Wallet_status');
+  return status;
+}
+
+String Wallet_errorString(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_errorString');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_errorString(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_errorString', e);
+    debugEnd?.call('WOWNERO_Wallet_errorString');
+    return "";
+  }
+}
+
+bool Wallet_setPassword(wallet ptr, {required String password}) {
+  debugStart?.call('WOWNERO_Wallet_setPassword');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Wallet_setPassword(ptr, password_);
+  calloc.free(password_);
+  debugEnd?.call('WOWNERO_Wallet_setPassword');
+  return status;
+}
+
+String Wallet_getPassword(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getPassword');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_getPassword(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getPassword');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getPassword', e);
+    debugEnd?.call('WOWNERO_Wallet_getPassword');
+    return "";
+  }
+}
+
+bool Wallet_setDevicePin(wallet ptr, {required String passphrase}) {
+  debugStart?.call('WOWNERO_Wallet_setDevicePin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final passphrase_ = passphrase.toNativeUtf8().cast<Char>();
+  final status = lib!.WOWNERO_Wallet_setDevicePin(ptr, passphrase_);
+  calloc.free(passphrase_);
+  debugEnd?.call('WOWNERO_Wallet_setDevicePin');
+  return status;
+}
+
+String Wallet_address(wallet ptr,
+    {int accountIndex = 0, int addressIndex = 0}) {
+  debugStart?.call('WOWNERO_Wallet_address');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_Wallet_address(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_address');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_address', e);
+    debugEnd?.call('WOWNERO_Wallet_address');
+    return "";
+  }
+}
+
+String Wallet_path(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_path');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_path(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_path');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_path', e);
+    debugEnd?.call('WOWNERO_Wallet_path');
+    return "";
+  }
+}
+
+int Wallet_nettype(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_nettype');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_nettype(ptr);
+  debugEnd?.call('WOWNERO_Wallet_nettype');
+  return status;
+}
+
+int Wallet_useForkRules(
+  wallet ptr, {
+  required int version,
+  required int earlyBlocks,
+}) {
+  debugStart?.call('WOWNERO_Wallet_useForkRules');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_useForkRules(ptr, version, earlyBlocks);
+  debugEnd?.call('WOWNERO_Wallet_useForkRules');
+  return status;
+}
+
+String Wallet_integratedAddress(wallet ptr, {required String paymentId}) {
+  debugStart?.call('WOWNERO_Wallet_integratedAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_integratedAddress(ptr, paymentId_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_integratedAddress');
+    calloc.free(paymentId_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_integratedAddress', e);
+    debugEnd?.call('WOWNERO_Wallet_integratedAddress');
+    return "";
+  }
+}
+
+String Wallet_secretViewKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_secretViewKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_secretViewKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_secretViewKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_secretViewKey', e);
+    debugEnd?.call('WOWNERO_Wallet_secretViewKey');
+    return "";
+  }
+}
+
+String Wallet_publicViewKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_publicViewKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_publicViewKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_publicViewKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_publicViewKey', e);
+    debugEnd?.call('WOWNERO_Wallet_publicViewKey');
+    return "";
+  }
+}
+
+String Wallet_secretSpendKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_secretSpendKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_secretSpendKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_secretSpendKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_secretSpendKey', e);
+    debugEnd?.call('WOWNERO_Wallet_secretSpendKey');
+    return "";
+  }
+}
+
+String Wallet_publicSpendKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_publicSpendKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_publicSpendKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_publicSpendKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_publicSpendKey', e);
+    debugEnd?.call('WOWNERO_Wallet_publicSpendKey');
+    return "";
+  }
+}
+
+String Wallet_publicMultisigSignerKey(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_publicMultisigSignerKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr =
+        lib!.WOWNERO_Wallet_publicMultisigSignerKey(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_publicMultisigSignerKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_publicMultisigSignerKey', e);
+    debugEnd?.call('WOWNERO_Wallet_publicMultisigSignerKey');
+    return "";
+  }
+}
+
+void Wallet_stop(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_stop');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final stop = lib!.WOWNERO_Wallet_stop(ptr);
+  debugEnd?.call('WOWNERO_Wallet_stop');
+  return stop;
+}
+
+bool Wallet_store(wallet ptr, {String path = ""}) {
+  debugStart?.call('WOWNERO_Wallet_store');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_store(ptr, path_);
+  calloc.free(path_);
+  debugEnd?.call('WOWNERO_Wallet_store');
+  return s;
+}
+
+String Wallet_filename(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_filename');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_filename(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_filename');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_filename', e);
+    debugEnd?.call('WOWNERO_Wallet_filename');
+    return "";
+  }
+}
+
+String Wallet_keysFilename(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_keysFilename');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_keysFilename(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_keysFilename');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_keysFilename', e);
+    debugEnd?.call('WOWNERO_Wallet_keysFilename');
+    return "";
+  }
+}
+
+bool Wallet_init(
+  wallet ptr, {
+  required String daemonAddress,
+  int upperTransacationSizeLimit = 0,
+  String daemonUsername = "",
+  String daemonPassword = "",
+  bool useSsl = false,
+  bool lightWallet = false,
+  String proxyAddress = "",
+}) {
+  debugStart?.call('WOWNERO_Wallet_init');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final daemonAddress_ = daemonAddress.toNativeUtf8().cast<Char>();
+  final daemonUsername_ = daemonUsername.toNativeUtf8().cast<Char>();
+  final daemonPassword_ = daemonPassword.toNativeUtf8().cast<Char>();
+  final proxyAddress_ = proxyAddress.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_init(
+      ptr,
+      daemonAddress_,
+      upperTransacationSizeLimit,
+      daemonUsername_,
+      daemonPassword_,
+      useSsl,
+      lightWallet,
+      proxyAddress_);
+
+  calloc.free(daemonAddress_);
+  calloc.free(daemonUsername_);
+  calloc.free(daemonPassword_);
+  calloc.free(proxyAddress_);
+  debugEnd?.call('WOWNERO_Wallet_init');
+  return s;
+}
+
+bool Wallet_createWatchOnly(
+  wallet ptr, {
+  required String path,
+  required String password,
+  required String language,
+}) {
+  debugStart?.call('WOWNERO_Wallet_createWatchOnly');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final getRefreshFromBlockHeight =
+      lib!.WOWNERO_Wallet_createWatchOnly(ptr, path_, password_, language_);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_Wallet_createWatchOnly');
+  return getRefreshFromBlockHeight;
+}
+
+void Wallet_setRefreshFromBlockHeight(wallet ptr,
+    {required int refresh_from_block_height}) {
+  debugStart?.call('WOWNERO_Wallet_setRefreshFromBlockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!
+      .WOWNERO_Wallet_setRefreshFromBlockHeight(ptr, refresh_from_block_height);
+  debugEnd?.call('WOWNERO_Wallet_setRefreshFromBlockHeight');
+  return status;
+}
+
+int Wallet_getRefreshFromBlockHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getRefreshFromBlockHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final getRefreshFromBlockHeight =
+      lib!.WOWNERO_Wallet_getRefreshFromBlockHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getRefreshFromBlockHeight');
+  return getRefreshFromBlockHeight;
+}
+
+void Wallet_setRecoveringFromSeed(wallet ptr,
+    {required bool recoveringFromSeed}) {
+  debugStart?.call('WOWNERO_Wallet_setRecoveringFromSeed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.WOWNERO_Wallet_setRecoveringFromSeed(ptr, recoveringFromSeed);
+  debugEnd?.call('WOWNERO_Wallet_setRecoveringFromSeed');
+  return status;
+}
+
+void Wallet_setRecoveringFromDevice(wallet ptr,
+    {required bool recoveringFromDevice}) {
+  debugStart?.call('WOWNERO_Wallet_setRecoveringFromDevice');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status =
+      lib!.WOWNERO_Wallet_setRecoveringFromDevice(ptr, recoveringFromDevice);
+  debugEnd?.call('WOWNERO_Wallet_setRecoveringFromDevice');
+  return status;
+}
+
+void Wallet_setSubaddressLookahead(wallet ptr,
+    {required int major, required int minor}) {
+  debugStart?.call('WOWNERO_Wallet_setSubaddressLookahead');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_setSubaddressLookahead(ptr, major, minor);
+  debugEnd?.call('WOWNERO_Wallet_setSubaddressLookahead');
+  return status;
+}
+
+bool Wallet_connectToDaemon(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_connectToDaemon');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final connectToDaemon = lib!.WOWNERO_Wallet_connectToDaemon(ptr);
+  debugEnd?.call('WOWNERO_Wallet_connectToDaemon');
+  return connectToDaemon;
+}
+
+int Wallet_connected(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_connected');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final connected = lib!.WOWNERO_Wallet_connected(ptr);
+  debugEnd?.call('WOWNERO_Wallet_connected');
+  return connected;
+}
+
+void Wallet_setTrustedDaemon(wallet ptr, {required bool arg}) {
+  debugStart?.call('WOWNERO_Wallet_setTrustedDaemon');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_setTrustedDaemon(ptr, arg);
+  debugEnd?.call('WOWNERO_Wallet_setTrustedDaemon');
+  return status;
+}
+
+bool Wallet_trustedDaemon(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_trustedDaemon');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final status = lib!.WOWNERO_Wallet_trustedDaemon(ptr);
+  debugEnd?.call('WOWNERO_Wallet_trustedDaemon');
+  return status;
+}
+
+bool Wallet_setProxy(wallet ptr, {required String address}) {
+  debugStart?.call('WOWNERO_Wallet_setProxy');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_setProxy(ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_Wallet_setProxy');
+  return s;
+}
+
+int Wallet_balance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_balance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final balance = lib!.WOWNERO_Wallet_balance(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_balance');
+  return balance;
+}
+
+int Wallet_unlockedBalance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_unlockedBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final unlockedBalance =
+      lib!.WOWNERO_Wallet_unlockedBalance(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_unlockedBalance');
+  return unlockedBalance;
+}
+
+int Wallet_viewOnlyBalance(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_viewOnlyBalance');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final unlockedBalance =
+      lib!.WOWNERO_Wallet_viewOnlyBalance(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_viewOnlyBalance');
+  return unlockedBalance;
+}
+
+bool Wallet_watchOnly(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_watchOnly');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final watchOnly = lib!.WOWNERO_Wallet_watchOnly(ptr);
+  debugEnd?.call('WOWNERO_Wallet_watchOnly');
+  return watchOnly;
+}
+
+int Wallet_blockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_blockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final blockChainHeight = lib!.WOWNERO_Wallet_blockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_blockChainHeight');
+  return blockChainHeight;
+}
+
+int Wallet_approximateBlockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_approximateBlockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final approximateBlockChainHeight =
+      lib!.WOWNERO_Wallet_approximateBlockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_approximateBlockChainHeight');
+  return approximateBlockChainHeight;
+}
+
+int Wallet_estimateBlockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_estimateBlockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final estimateBlockChainHeight =
+      lib!.WOWNERO_Wallet_estimateBlockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_estimateBlockChainHeight');
+  return estimateBlockChainHeight;
+}
+
+int Wallet_daemonBlockChainHeight(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_daemonBlockChainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final daemonBlockChainHeight =
+      lib!.WOWNERO_Wallet_daemonBlockChainHeight(ptr);
+  debugEnd?.call('WOWNERO_Wallet_daemonBlockChainHeight');
+  return daemonBlockChainHeight;
+}
+
+int Wallet_daemonBlockChainHeight_cached(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_daemonBlockChainHeight_cached');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final daemonBlockChainHeight =
+      lib!.WOWNERO_Wallet_daemonBlockChainHeight_cached(ptr);
+  debugEnd?.call('WOWNERO_Wallet_daemonBlockChainHeight_cached');
+  return daemonBlockChainHeight;
+}
+
+void Wallet_daemonBlockChainHeight_runThread(wallet ptr, int seconds) {
+  debugStart?.call('WOWNERO_Wallet_daemonBlockChainHeight_enableRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final ret =
+      lib!.WOWNERO_Wallet_daemonBlockChainHeight_runThread(ptr, seconds);
+  debugEnd?.call('WOWNERO_Wallet_daemonBlockChainHeight_enableRefresh');
+  return ret;
+}
+
+bool Wallet_synchronized(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_synchronized');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final synchronized = lib!.WOWNERO_Wallet_synchronized(ptr);
+  debugEnd?.call('WOWNERO_Wallet_synchronized');
+  return synchronized;
+}
+
+String Wallet_displayAmount(int amount) {
+  debugStart?.call('WOWNERO_Wallet_displayAmount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_displayAmount(amount).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_displayAmount');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_displayAmount', e);
+    debugEnd?.call('WOWNERO_Wallet_displayAmount');
+    return "";
+  }
+}
+
+int Wallet_amountFromString(String amount) {
+  debugStart?.call('WOWNERO_Wallet_amountFromString');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final amount_ = amount.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_amountFromString(amount_);
+  calloc.free(amount_);
+  debugEnd?.call('WOWNERO_Wallet_amountFromString');
+  return s;
+}
+
+int Wallet_amountFromDouble(double amount) {
+  debugStart?.call('WOWNERO_Wallet_amountFromDouble');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_Wallet_amountFromDouble(amount);
+  debugEnd?.call('WOWNERO_Wallet_amountFromDouble');
+  return s;
+}
+
+String Wallet_genPaymentId() {
+  debugStart?.call('WOWNERO_Wallet_genPaymentId');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_genPaymentId().cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_genPaymentId');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_genPaymentId', e);
+    debugEnd?.call('WOWNERO_Wallet_genPaymentId');
+    return "";
+  }
+}
+
+bool Wallet_paymentIdValid(String paymentId) {
+  debugStart?.call('WOWNERO_Wallet_paymentIdValid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final paymentId_ = paymentId.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_paymentIdValid(paymentId_);
+  calloc.free(paymentId_);
+  debugEnd?.call('WOWNERO_Wallet_paymentIdValid');
+  return s;
+}
+
+bool Wallet_addressValid(String address, int networkType) {
+  debugStart?.call('WOWNERO_Wallet_addressValid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_addressValid(address_, networkType);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_Wallet_addressValid');
+  return s;
+}
+
+bool Wallet_keyValid(
+    {required String secret_key_string,
+    required String address_string,
+    required bool isViewKey,
+    required int nettype}) {
+  debugStart?.call('WOWNERO_Wallet_keyValid');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final secret_key_string_ = secret_key_string.toNativeUtf8().cast<Char>();
+  final address_string_ = address_string.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_keyValid(
+      secret_key_string_, address_string_, isViewKey, nettype);
+  calloc.free(secret_key_string_);
+  calloc.free(address_string_);
+  debugEnd?.call('WOWNERO_Wallet_keyValid');
+  return s;
+}
+
+String Wallet_keyValid_error(
+    {required String secret_key_string,
+    required String address_string,
+    required bool isViewKey,
+    required int nettype}) {
+  debugStart?.call('WOWNERO_Wallet_keyValid_error');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final secret_key_string_ = secret_key_string.toNativeUtf8().cast<Char>();
+    final address_string_ = address_string.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .WOWNERO_Wallet_keyValid_error(
+            secret_key_string_, address_string_, isViewKey, nettype)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(secret_key_string_);
+    calloc.free(address_string_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_keyValid_error', e);
+    debugEnd?.call('WOWNERO_Wallet_keyValid_error');
+    return "";
+  }
+}
+
+String Wallet_paymentIdFromAddress(
+    {required String strarg, required int nettype}) {
+  debugStart?.call('WOWNERO_Wallet_paymentIdFromAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strarg_ = strarg.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_paymentIdFromAddress(strarg_, nettype).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(strarg_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_paymentIdFromAddress', e);
+    debugEnd?.call('WOWNERO_Wallet_paymentIdFromAddress');
+    return "";
+  }
+}
+
+int Wallet_maximumAllowedAmount() {
+  debugStart?.call('WOWNERO_Wallet_maximumAllowedAmount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_Wallet_maximumAllowedAmount();
+  debugEnd?.call('WOWNERO_Wallet_maximumAllowedAmount');
+  return s;
+}
+
+void Wallet_init3(
+  wallet ptr, {
+  required String argv0,
+  required String defaultLogBaseName,
+  required String logPath,
+  required bool console,
+}) {
+  debugStart?.call('WOWNERO_Wallet_init3');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final argv0_ = argv0.toNativeUtf8().cast<Char>();
+  final defaultLogBaseName_ = defaultLogBaseName.toNativeUtf8().cast<Char>();
+  final logPath_ = logPath.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_init3(
+      ptr, argv0_, defaultLogBaseName_, logPath_, console);
+  calloc.free(argv0_);
+  calloc.free(defaultLogBaseName_);
+  calloc.free(logPath_);
+  debugEnd?.call('WOWNERO_Wallet_init3');
+  return s;
+}
+
+String Wallet_getPolyseed(wallet ptr, {required String passphrase}) {
+  debugStart?.call('WOWNERO_Wallet_getPolyseed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final passphrase_ = passphrase.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_getPolyseed(ptr, passphrase_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(passphrase_);
+    debugEnd?.call('WOWNERO_Wallet_getPolyseed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getPolyseed', e);
+    debugEnd?.call('WOWNERO_Wallet_getPolyseed');
+    return "";
+  }
+}
+
+String Wallet_createPolyseed({
+  String language = "English",
+}) {
+  debugStart?.call('WOWNERO_Wallet_createPolyseed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final language_ = language.toNativeUtf8();
+    final strPtr =
+        lib!.WOWNERO_Wallet_createPolyseed(language_.cast()).cast<Utf8>();
+    calloc.free(language_);
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_createPolyseed');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_createPolyseed', e);
+    debugEnd?.call('WOWNERO_Wallet_createPolyseed');
+    return "";
+  }
+}
+
+void Wallet_startRefresh(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_startRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final startRefresh = lib!.WOWNERO_Wallet_startRefresh(ptr);
+  debugEnd?.call('WOWNERO_Wallet_startRefresh');
+  return startRefresh;
+}
+
+void Wallet_pauseRefresh(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_pauseRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final pauseRefresh = lib!.WOWNERO_Wallet_pauseRefresh(ptr);
+  debugEnd?.call('WOWNERO_Wallet_pauseRefresh');
+  return pauseRefresh;
+}
+
+bool Wallet_refresh(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_refresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final refresh = lib!.WOWNERO_Wallet_refresh(ptr);
+  debugEnd?.call('WOWNERO_Wallet_refresh');
+  return refresh;
+}
+
+void Wallet_refreshAsync(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_refreshAsync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final refreshAsync = lib!.WOWNERO_Wallet_refreshAsync(ptr);
+  debugEnd?.call('WOWNERO_Wallet_refreshAsync');
+  return refreshAsync;
+}
+
+bool Wallet_rescanBlockchain(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_rescanBlockchain');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final rescanBlockchain = lib!.WOWNERO_Wallet_rescanBlockchain(ptr);
+  debugEnd?.call('WOWNERO_Wallet_rescanBlockchain');
+  return rescanBlockchain;
+}
+
+void Wallet_rescanBlockchainAsync(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_rescanBlockchainAsync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final rescanBlockchainAsync = lib!.WOWNERO_Wallet_rescanBlockchainAsync(ptr);
+  debugEnd?.call('WOWNERO_Wallet_rescanBlockchainAsync');
+  return rescanBlockchainAsync;
+}
+
+void Wallet_setAutoRefreshInterval(wallet ptr, {required int millis}) {
+  debugStart?.call('WOWNERO_Wallet_setAutoRefreshInterval');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final setAutoRefreshInterval =
+      lib!.WOWNERO_Wallet_setAutoRefreshInterval(ptr, millis);
+  debugEnd?.call('WOWNERO_Wallet_setAutoRefreshInterval');
+  return setAutoRefreshInterval;
+}
+
+int Wallet_autoRefreshInterval(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_autoRefreshInterval');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final autoRefreshInterval = lib!.WOWNERO_Wallet_autoRefreshInterval(ptr);
+  debugEnd?.call('WOWNERO_Wallet_autoRefreshInterval');
+  return autoRefreshInterval;
+}
+
+void Wallet_addSubaddress(wallet ptr,
+    {required int accountIndex, String label = ""}) {
+  debugStart?.call('WOWNERO_Wallet_addSubaddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_addSubaddress(ptr, accountIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Wallet_addSubaddress');
+  return s;
+}
+
+void Wallet_addSubaddressAccount(wallet ptr, {String label = ""}) {
+  debugStart?.call('WOWNERO_Wallet_addSubaddressAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_addSubaddressAccount(ptr, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Wallet_addSubaddressAccount');
+  return s;
+}
+
+int Wallet_numSubaddressAccounts(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_numSubaddressAccounts');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final numSubaddressAccounts = lib!.WOWNERO_Wallet_numSubaddressAccounts(ptr);
+  debugEnd?.call('WOWNERO_Wallet_numSubaddressAccounts');
+  return numSubaddressAccounts;
+}
+
+int Wallet_numSubaddresses(wallet ptr, {required int accountIndex}) {
+  debugStart?.call('WOWNERO_Wallet_numSubaddresses');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final numSubaddresses =
+      lib!.WOWNERO_Wallet_numSubaddresses(ptr, accountIndex);
+  debugEnd?.call('WOWNERO_Wallet_numSubaddresses');
+  return numSubaddresses;
+}
+
+String Wallet_getSubaddressLabel(wallet ptr,
+    {required int accountIndex, required int addressIndex}) {
+  debugStart?.call('WOWNERO_Wallet_getSubaddressLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_Wallet_getSubaddressLabel(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getSubaddressLabel');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getSubaddressLabel', e);
+    debugEnd?.call('WOWNERO_Wallet_getSubaddressLabel');
+    return "";
+  }
+}
+
+void Wallet_setSubaddressLabel(wallet ptr,
+    {required int accountIndex,
+    required int addressIndex,
+    required String label}) {
+  debugStart?.call('WOWNERO_Wallet_setSubaddressLabel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final label_ = label.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_setSubaddressLabel(
+      ptr, accountIndex, addressIndex, label_);
+  calloc.free(label_);
+  debugEnd?.call('WOWNERO_Wallet_setSubaddressLabel');
+  return s;
+}
+
+String Wallet_getMultisigInfo(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getMultisigInfo');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_Wallet_getMultisigInfo(ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_getMultisigInfo');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getMultisigInfo', e);
+    debugEnd?.call('WOWNERO_Wallet_getMultisigInfo');
+    return "";
+  }
+}
+
+PendingTransaction Wallet_createTransactionMultDest(
+  wallet wptr, {
+  required List<String> dstAddr,
+  String paymentId = "",
+  required bool isSweepAll,
+  required List<int> amounts,
+  required int mixinCount,
+  required int pendingTransactionPriority,
+  required int subaddr_account,
+  List<String> preferredInputs = const [],
+}) {
+  debugStart?.call('WOWNERO_Wallet_createTransactionMultDest');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final dst_addr_list = dstAddr.join(defaultSeparatorStr).toNativeUtf8();
+  final payment_id = paymentId.toNativeUtf8();
+  final amount_list =
+      amounts.map((e) => e.toString()).join(defaultSeparatorStr).toNativeUtf8();
+  final preferredInputs_ =
+      preferredInputs.join(defaultSeparatorStr).toNativeUtf8();
+  final ret = lib!.WOWNERO_Wallet_createTransactionMultDest(
+    wptr,
+    dst_addr_list.cast(),
+    defaultSeparator,
+    payment_id.cast(),
+    isSweepAll,
+    amount_list.cast(),
+    defaultSeparator,
+    mixinCount,
+    pendingTransactionPriority,
+    subaddr_account,
+    preferredInputs_.cast(),
+    defaultSeparator,
+  );
+  calloc.free(dst_addr_list);
+  calloc.free(payment_id);
+  calloc.free(amount_list);
+  calloc.free(preferredInputs_);
+  debugEnd?.call('WOWNERO_Wallet_createTransactionMultDest');
+  return ret;
+}
+
+PendingTransaction Wallet_createTransaction(wallet ptr,
+    {required String dst_addr,
+    required String payment_id,
+    required int amount,
+    required int mixin_count,
+    required int pendingTransactionPriority,
+    required int subaddr_account,
+    List<String> preferredInputs = const []}) {
+  debugStart?.call('WOWNERO_Wallet_createTransaction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final dst_addr_ = dst_addr.toNativeUtf8().cast<Char>();
+  final payment_id_ = payment_id.toNativeUtf8().cast<Char>();
+  final preferredInputs_ =
+      preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_createTransaction(
+    ptr,
+    dst_addr_,
+    payment_id_,
+    amount,
+    mixin_count,
+    pendingTransactionPriority,
+    subaddr_account,
+    preferredInputs_,
+    defaultSeparator,
+  );
+  calloc.free(dst_addr_);
+  calloc.free(payment_id_);
+  calloc.free(preferredInputs_);
+  debugEnd?.call('WOWNERO_Wallet_createTransaction');
+  return s;
+}
+
+UnsignedTransaction Wallet_loadUnsignedTx(wallet ptr,
+    {required String unsigned_filename}) {
+  debugStart?.call('WOWNERO_Wallet_loadUnsignedTx');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final unsigned_filename_ = unsigned_filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_loadUnsignedTx(ptr, unsigned_filename_);
+  calloc.free(unsigned_filename_);
+  debugEnd?.call('WOWNERO_Wallet_loadUnsignedTx');
+  return s;
+}
+
+bool Wallet_submitTransaction(wallet ptr, String filename) {
+  debugStart?.call('WOWNERO_Wallet_submitTransaction');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_submitTransaction(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_submitTransaction');
+  return s;
+}
+
+bool Wallet_hasUnknownKeyImages(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_hasUnknownKeyImages');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_Wallet_hasUnknownKeyImages(ptr);
+  debugEnd?.call('WOWNERO_Wallet_hasUnknownKeyImages');
+  return s;
+}
+
+bool Wallet_exportKeyImages(wallet ptr, String filename, {required bool all}) {
+  debugStart?.call('WOWNERO_Wallet_exportKeyImages');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_exportKeyImages(ptr, filename_, all);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_exportKeyImages');
+  return s;
+}
+
+bool Wallet_importKeyImages(wallet ptr, String filename) {
+  debugStart?.call('WOWNERO_Wallet_importKeyImages');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_importKeyImages(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_importKeyImages');
+  return s;
+}
+
+bool Wallet_exportOutputs(wallet ptr, String filename, {required bool all}) {
+  debugStart?.call('WOWNERO_Wallet_exportOutputs');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_exportOutputs(ptr, filename_, all);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_exportOutputs');
+  return s;
+}
+
+bool Wallet_importOutputs(wallet ptr, String filename) {
+  debugStart?.call('WOWNERO_Wallet_importOutputs');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final filename_ = filename.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_importOutputs(ptr, filename_);
+  calloc.free(filename_);
+  debugEnd?.call('WOWNERO_Wallet_importOutputs');
+  return s;
+}
+
+bool Wallet_setupBackgroundSync(
+  wallet ptr, {
+  required int backgroundSyncType,
+  required String walletPassword,
+  required String backgroundCachePassword,
+}) {
+  debugStart?.call('WOWNERO_Wallet_setupBackgroundSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final walletPassword_ = walletPassword.toNativeUtf8().cast<Char>();
+  final backgroundCachePassword_ =
+      backgroundCachePassword.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_Wallet_setupBackgroundSync(
+      ptr, backgroundSyncType, walletPassword_, backgroundCachePassword_);
+  calloc.free(walletPassword_);
+  calloc.free(backgroundCachePassword_);
+  debugEnd?.call('WOWNERO_Wallet_setupBackgroundSync');
+  return s;
+}
+
+int Wallet_getBackgroundSyncType(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getBackgroundSyncType');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_getBackgroundSyncType(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getBackgroundSyncType');
+  return v;
+}
+
+bool Wallet_startBackgroundSync(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_startBackgroundSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_startBackgroundSync(ptr);
+  debugEnd?.call('WOWNERO_Wallet_startBackgroundSync');
+  return v;
+}
+
+bool Wallet_stopBackgroundSync(wallet ptr, String walletPassword) {
+  debugStart?.call('WOWNERO_Wallet_stopBackgroundSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final walletPassword_ = walletPassword.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Wallet_stopBackgroundSync(ptr, walletPassword_);
+  calloc.free(walletPassword_);
+  debugEnd?.call('WOWNERO_Wallet_stopBackgroundSync');
+  return v;
+}
+
+bool Wallet_isBackgroundSyncing(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isBackgroundSyncing');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_isBackgroundSyncing(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isBackgroundSyncing');
+  return v;
+}
+
+bool Wallet_isBackgroundWallet(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isBackgroundWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_isBackgroundWallet(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isBackgroundWallet');
+  return v;
+}
+
+TransactionHistory Wallet_history(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_history');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_history(ptr);
+  debugEnd?.call('WOWNERO_Wallet_history');
+  return history;
+}
+
+AddressBook Wallet_addressBook(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_addressBook');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_addressBook(ptr);
+  debugEnd?.call('WOWNERO_Wallet_addressBook');
+  return history;
+}
+
+AddressBook Wallet_coins(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_coins');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_coins(ptr);
+  debugEnd?.call('WOWNERO_Wallet_coins');
+  return history;
+}
+
+AddressBook Wallet_subaddress(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_subaddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_subaddress(ptr);
+  debugEnd?.call('WOWNERO_Wallet_subaddress');
+  return history;
+}
+
+AddressBook Wallet_subaddressAccount(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_subaddressAccount');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final history = lib!.WOWNERO_Wallet_subaddressAccount(ptr);
+  debugEnd?.call('WOWNERO_Wallet_subaddressAccount');
+  return history;
+}
+
+int Wallet_defaultMixin(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_defaultMixin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_defaultMixin(ptr);
+  debugEnd?.call('WOWNERO_Wallet_defaultMixin');
+  return v;
+}
+
+void Wallet_setDefaultMixin(wallet ptr, int arg) {
+  debugStart?.call('WOWNERO_Wallet_setDefaultMixin');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_setDefaultMixin(ptr, arg);
+  debugEnd?.call('WOWNERO_Wallet_setDefaultMixin');
+  return v;
+}
+
+bool Wallet_setCacheAttribute(wallet ptr,
+    {required String key, required String value}) {
+  debugStart?.call('WOWNERO_Wallet_setCacheAttribute');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final key_ = key.toNativeUtf8().cast<Char>();
+  final value_ = value.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Wallet_setCacheAttribute(ptr, key_, value_);
+  calloc.free(key_);
+  calloc.free(value_);
+  debugEnd?.call('WOWNERO_Wallet_setCacheAttribute');
+  return v;
+}
+
+String Wallet_getCacheAttribute(wallet ptr, {required String key}) {
+  debugStart?.call('WOWNERO_Wallet_getCacheAttribute');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final key_ = key.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_getCacheAttribute(ptr, key_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(key_);
+    debugEnd?.call('WOWNERO_Wallet_getCacheAttribute');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getCacheAttribute', e);
+    debugEnd?.call('WOWNERO_Wallet_getCacheAttribute');
+    return "";
+  }
+}
+
+bool Wallet_setUserNote(wallet ptr,
+    {required String txid, required String note}) {
+  debugStart?.call('WOWNERO_Wallet_setUserNote');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final txid_ = txid.toNativeUtf8().cast<Char>();
+  final note_ = note.toNativeUtf8().cast<Char>();
+  final v = lib!.WOWNERO_Wallet_setUserNote(ptr, txid_, note_);
+  calloc.free(txid_);
+  calloc.free(note_);
+  debugEnd?.call('WOWNERO_Wallet_setUserNote');
+  return v;
+}
+
+String Wallet_getUserNote(wallet ptr, {required String txid}) {
+  debugStart?.call('WOWNERO_Wallet_getUserNote');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final txid_ = txid.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.WOWNERO_Wallet_getUserNote(ptr, txid_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(txid_);
+    debugEnd?.call('WOWNERO_Wallet_getUserNote');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getUserNote', e);
+    debugEnd?.call('WOWNERO_Wallet_getUserNote');
+    return "";
+  }
+}
+
+String Wallet_getTxKey(wallet ptr, {required String txid}) {
+  debugStart?.call('WOWNERO_Wallet_getTxKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final txid_ = txid.toNativeUtf8().cast<Char>();
+    final strPtr = lib!.WOWNERO_Wallet_getTxKey(ptr, txid_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(txid_);
+    debugEnd?.call('WOWNERO_Wallet_getTxKey');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_getTxKey', e);
+    debugEnd?.call('WOWNERO_Wallet_getTxKey');
+    return "";
+  }
+}
+
+String Wallet_signMessage(
+  wallet ptr, {
+  required String message,
+  required String address,
+}) {
+  debugStart?.call('WOWNERO_Wallet_signMessage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final message_ = message.toNativeUtf8().cast<Char>();
+    final address_ = address.toNativeUtf8().cast<Char>();
+    final strPtr =
+        lib!.WOWNERO_Wallet_signMessage(ptr, message_, address_).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    calloc.free(message_);
+    calloc.free(address_);
+    debugEnd?.call('WOWNERO_Wallet_signMessage');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_signMessage', e);
+    debugEnd?.call('WOWNERO_Wallet_signMessage');
+    return "";
+  }
+}
+
+bool Wallet_verifySignedMessage(
+  wallet ptr, {
+  required String message,
+  required String address,
+  required String signature,
+}) {
+  debugStart?.call('WOWNERO_Wallet_verifySignedMessage');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final message_ = message.toNativeUtf8().cast<Char>();
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final signature_ = signature.toNativeUtf8().cast<Char>();
+  final v = lib!
+      .WOWNERO_Wallet_verifySignedMessage(ptr, message_, address_, signature_);
+  calloc.free(message_);
+  calloc.free(address_);
+  calloc.free(signature_);
+  debugEnd?.call('WOWNERO_Wallet_verifySignedMessage');
+  return v;
+}
+
+bool Wallet_rescanSpent(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_rescanSpent');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_rescanSpent(ptr);
+  debugEnd?.call('WOWNERO_Wallet_rescanSpent');
+  return v;
+}
+
+void Wallet_setOffline(wallet ptr, {required bool offline}) {
+  debugStart?.call('WOWNERO_Wallet_setOffline');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final setOffline = lib!.WOWNERO_Wallet_setOffline(ptr, offline);
+  debugEnd?.call('WOWNERO_Wallet_setOffline');
+  return setOffline;
+}
+
+bool Wallet_isOffline(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isOffline');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final isOffline = lib!.WOWNERO_Wallet_isOffline(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isOffline');
+  return isOffline;
+}
+
+void Wallet_segregatePreForkOutputs(wallet ptr, {required bool segregate}) {
+  debugStart?.call('WOWNERO_Wallet_segregatePreForkOutputs');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_segregatePreForkOutputs(ptr, segregate);
+  debugEnd?.call('WOWNERO_Wallet_segregatePreForkOutputs');
+  return v;
+}
+
+void Wallet_segregationHeight(wallet ptr, {required int height}) {
+  debugStart?.call('WOWNERO_Wallet_segregationHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_segregationHeight(ptr, height);
+  debugEnd?.call('WOWNERO_Wallet_segregationHeight');
+  return v;
+}
+
+void Wallet_keyReuseMitigation2(wallet ptr, {required bool mitigation}) {
+  debugStart?.call('WOWNERO_Wallet_keyReuseMitigation2');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_keyReuseMitigation2(ptr, mitigation);
+  debugEnd?.call('WOWNERO_Wallet_keyReuseMitigation2');
+  return v;
+}
+
+bool Wallet_lockKeysFile(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_lockKeysFile');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_lockKeysFile(ptr);
+  debugEnd?.call('WOWNERO_Wallet_lockKeysFile');
+  return v;
+}
+
+bool Wallet_unlockKeysFile(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_unlockKeysFile');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_unlockKeysFile(ptr);
+  debugEnd?.call('WOWNERO_Wallet_unlockKeysFile');
+  return v;
+}
+
+bool Wallet_isKeysFileLocked(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_isKeysFileLocked');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_isKeysFileLocked(ptr);
+  debugEnd?.call('WOWNERO_Wallet_isKeysFileLocked');
+  return v;
+}
+
+int Wallet_getDeviceType(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getDeviceType');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_getDeviceType(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getDeviceType');
+  return v;
+}
+
+int Wallet_coldKeyImageSync(wallet ptr,
+    {required int spent, required int unspent}) {
+  debugStart?.call('WOWNERO_Wallet_coldKeyImageSync');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final v = lib!.WOWNERO_Wallet_coldKeyImageSync(ptr, spent, unspent);
+  debugEnd?.call('WOWNERO_Wallet_coldKeyImageSync');
+  return v;
+}
+
+String Wallet_deviceShowAddress(wallet ptr,
+    {required int accountIndex, required int addressIndex}) {
+  debugStart?.call('WOWNERO_Wallet_deviceShowAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!
+        .WOWNERO_Wallet_deviceShowAddress(ptr, accountIndex, addressIndex)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_Wallet_deviceShowAddress');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_Wallet_deviceShowAddress', e);
+    debugEnd?.call('WOWNERO_Wallet_deviceShowAddress');
+    return "";
+  }
+}
+
+bool Wallet_reconnectDevice(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_reconnectDevice');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final ret = lib!.WOWNERO_Wallet_reconnectDevice(ptr);
+  return ret;
+}
+
+int Wallet_getBytesReceived(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getBytesReceived');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final getBytesReceived = lib!.WOWNERO_Wallet_getBytesReceived(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getBytesReceived');
+  return getBytesReceived;
+}
+
+int Wallet_getBytesSent(wallet ptr) {
+  debugStart?.call('WOWNERO_Wallet_getBytesReceived');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final getBytesSent = lib!.WOWNERO_Wallet_getBytesSent(ptr);
+  debugEnd?.call('WOWNERO_Wallet_getBytesReceived');
+  return getBytesSent;
+}
+
+// WalletManager
+
+typedef WalletManager = Pointer<Void>;
+
+wallet WalletManager_createWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  String language = "English",
+  int networkType = 0,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_createWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_createWallet(
+      wm_ptr, path_, password_, language_, networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_WalletManager_createWallet');
+  return w;
+}
+
+wallet WalletManager_openWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_openWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final w = lib!
+      .WOWNERO_WalletManager_openWallet(wm_ptr, path_, password_, networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  debugEnd?.call('WOWNERO_WalletManager_openWallet');
+  return w;
+}
+
+wallet WalletManager_recoveryWallet(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  required String mnemonic,
+  int networkType = 0,
+  required int restoreHeight,
+  int kdfRounds = 0,
+  required String seedOffset,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_recoveryWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final mnemonic_ = mnemonic.toNativeUtf8().cast<Char>();
+  final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_recoveryWallet(wm_ptr, path_, password_,
+      mnemonic_, networkType, restoreHeight, kdfRounds, seedOffset_);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(mnemonic_);
+  calloc.free(seedOffset_);
+  debugEnd?.call('WOWNERO_WalletManager_recoveryWallet');
+  return w;
+}
+
+wallet WalletManager_createWalletFromKeys(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  String language = "English",
+  int nettype = 1,
+  required int restoreHeight,
+  required String addressString,
+  required String viewKeyString,
+  required String spendKeyString,
+  int kdf_rounds = 1,
+}) {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  debugStart?.call('WOWNERO_WalletManager_createWalletFromKeys');
+
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final addressString_ = addressString.toNativeUtf8().cast<Char>();
+  final viewKeyString_ = viewKeyString.toNativeUtf8().cast<Char>();
+  final spendKeyString_ = spendKeyString.toNativeUtf8().cast<Char>();
+
+  final w = lib!.WOWNERO_WalletManager_createWalletFromKeys(
+    wm_ptr,
+    path_,
+    password_,
+    language_,
+    nettype,
+    restoreHeight,
+    addressString_,
+    viewKeyString_,
+    spendKeyString_,
+    kdf_rounds,
+  );
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  calloc.free(addressString_);
+  calloc.free(viewKeyString_);
+  calloc.free(spendKeyString_);
+  debugEnd?.call('WOWNERO_WalletManager_createWalletFromKeys');
+  return w;
+}
+
+wallet WalletManager_createDeterministicWalletFromSpendKey(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String language,
+  required String spendKeyString,
+  required bool newWallet,
+  required int restoreHeight,
+  int kdfRounds = 1,
+}) {
+  debugStart
+      ?.call('WOWNERO_WalletManager_createDeterministicWalletFromSpendKey');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final language_ = language.toNativeUtf8().cast<Char>();
+  final spendKeyString_ = spendKeyString.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(
+      wm_ptr,
+      path_,
+      password_,
+      language_,
+      networkType,
+      restoreHeight,
+      spendKeyString_,
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  calloc.free(spendKeyString_);
+  debugEnd?.call('WOWNERO_WalletManager_createDeterministicWalletFromSpendKey');
+  return w;
+}
+
+wallet WalletManager_createWalletFromPolyseed(
+  WalletManager wm_ptr, {
+  required String path,
+  required String password,
+  int networkType = 0,
+  required String mnemonic,
+  required String seedOffset,
+  required bool newWallet,
+  required int restoreHeight,
+  required int kdfRounds,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_createWalletFromPolyseed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final mnemonic_ = mnemonic.toNativeUtf8().cast<Char>();
+  final seedOffset_ = seedOffset.toNativeUtf8().cast<Char>();
+  final w = lib!.WOWNERO_WalletManager_createWalletFromPolyseed(
+      wm_ptr,
+      path_,
+      password_,
+      networkType,
+      mnemonic_,
+      seedOffset_,
+      newWallet,
+      restoreHeight,
+      kdfRounds);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(mnemonic_);
+  calloc.free(seedOffset_);
+  debugEnd?.call('WOWNERO_WalletManager_createWalletFromPolyseed');
+  return w;
+}
+
+bool WalletManager_closeWallet(WalletManager wm_ptr, wallet ptr, bool store) {
+  debugStart?.call('WOWNERO_WalletManager_closeWallet');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final closeWallet =
+      lib!.WOWNERO_WalletManager_closeWallet(wm_ptr, ptr, store);
+  debugEnd?.call('WOWNERO_WalletManager_closeWallet');
+  return closeWallet;
+}
+
+bool WalletManager_walletExists(WalletManager wm_ptr, String path) {
+  debugStart?.call('WOWNERO_WalletManager_walletExists');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_walletExists(wm_ptr, path_);
+  calloc.free(path_);
+  debugEnd?.call('WOWNERO_WalletManager_walletExists');
+  return s;
+}
+
+bool WalletManager_verifyWalletPassword(
+  WalletManager wm_ptr, {
+  required String keysFileName,
+  required String password,
+  required bool noSpendKey,
+  required int kdfRounds,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_verifyWalletPassword');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final keysFileName_ = keysFileName.toNativeUtf8().cast<Char>();
+  final password_ = password.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_verifyWalletPassword(
+      wm_ptr, keysFileName_, password_, noSpendKey, kdfRounds);
+  calloc.free(keysFileName_);
+  calloc.free(password_);
+  debugEnd?.call('WOWNERO_WalletManager_verifyWalletPassword');
+  return s;
+}
+
+String WalletManager_findWallets(WalletManager wm_ptr, {required String path}) {
+  debugStart?.call('WOWNERO_WalletManager_findWallets');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final path_ = path.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .WOWNERO_WalletManager_findWallets(wm_ptr, path_, defaultSeparator)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    calloc.free(path_);
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_WalletManager_findWallets');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_WalletManager_findWallets', e);
+    debugEnd?.call('WOWNERO_WalletManager_findWallets');
+    return "";
+  }
+}
+
+String WalletManager_errorString(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_errorString');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final strPtr = lib!.WOWNERO_WalletManager_errorString(wm_ptr).cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_WalletManager_errorString');
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_WalletManager_errorString', e);
+    debugEnd?.call('WOWNERO_WalletManager_errorString');
+    return "";
+  }
+}
+
+void WalletManager_setDaemonAddress(WalletManager wm_ptr, String address) {
+  debugStart?.call('WOWNERO_WalletManager_setDaemonAddress');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_setDaemonAddress(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_setDaemonAddress');
+  return s;
+}
+
+int WalletManager_blockchainHeight(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_blockchainHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_blockchainHeight(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_blockchainHeight');
+  return s;
+}
+
+int WalletManager_blockchainTargetHeight(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_blockchainTargetHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_blockchainTargetHeight(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_blockchainTargetHeight');
+  return s;
+}
+
+int WalletManager_networkDifficulty(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_networkDifficulty');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_networkDifficulty(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_networkDifficulty');
+  return s;
+}
+
+double WalletManager_miningHashRate(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_miningHashRate');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_miningHashRate(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_miningHashRate');
+  return s;
+}
+
+int WalletManager_blockTarget(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_blockTarget');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_blockTarget(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_blockTarget');
+  return s;
+}
+
+bool WalletManager_isMining(WalletManager wm_ptr) {
+  debugStart?.call('WOWNERO_WalletManager_isMining');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManager_isMining(wm_ptr);
+  debugEnd?.call('WOWNERO_WalletManager_isMining');
+  return s;
+}
+
+bool WalletManager_startMining(
+  WalletManager wm_ptr, {
+  required String address,
+  required int threads,
+  required bool backgroundMining,
+  required bool ignoreBattery,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_startMining');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_startMining(
+      wm_ptr, address_, threads, backgroundMining, ignoreBattery);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_startMining');
+  return s;
+}
+
+bool WalletManager_stopMining(WalletManager wm_ptr, String address) {
+  debugStart?.call('WOWNERO_WalletManager_stopMining');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_stopMining(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_stopMining');
+  return s;
+}
+
+String WalletManager_resolveOpenAlias(
+  WalletManager wm_ptr, {
+  required String address,
+  required bool dnssecValid,
+}) {
+  debugStart?.call('WOWNERO_WalletManager_resolveOpenAlias');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  try {
+    final address_ = address.toNativeUtf8().cast<Char>();
+    final strPtr = lib!
+        .WOWNERO_WalletManager_resolveOpenAlias(wm_ptr, address_, dnssecValid)
+        .cast<Utf8>();
+    final str = strPtr.toDartString();
+    WOWNERO_free(strPtr.cast());
+    debugEnd?.call('WOWNERO_WalletManager_resolveOpenAlias');
+    calloc.free(address_);
+    return str;
+  } catch (e) {
+    errorHandler?.call('WOWNERO_WalletManager_resolveOpenAlias', e);
+    debugEnd?.call('WOWNERO_WalletManager_resolveOpenAlias');
+    return "";
+  }
+}
+
+bool WalletManager_setProxy(WalletManager wm_ptr, String address) {
+  debugStart?.call('WOWNERO_WalletManager_setProxy');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final address_ = address.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManager_setProxy(wm_ptr, address_);
+  calloc.free(address_);
+  debugEnd?.call('WOWNERO_WalletManager_setProxy');
+  return s;
+}
+
+void WalletManagerFactory_setLogLevel(int level) {
+  debugStart?.call('WOWNERO_WalletManagerFactory_setLogLevel');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManagerFactory_setLogLevel(level);
+  debugEnd?.call('WOWNERO_WalletManagerFactory_setLogLevel');
+  return s;
+}
+
+void WalletManagerFactory_setLogCategories(String categories) {
+  debugStart?.call('WOWNERO_WalletManagerFactory_setLogCategories');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final categories_ = categories.toNativeUtf8().cast<Char>();
+  final s = lib!.WOWNERO_WalletManagerFactory_setLogCategories(categories_);
+  calloc.free(categories_);
+  debugEnd?.call('WOWNERO_WalletManagerFactory_setLogCategories');
+  return s;
+}
+
+WalletManager WalletManagerFactory_getWalletManager() {
+  debugStart?.call('WOWNERO_WalletManagerFactory_getWalletManager');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final s = lib!.WOWNERO_WalletManagerFactory_getWalletManager();
+  debugEnd?.call('WOWNERO_WalletManagerFactory_getWalletManager');
+  return s;
+}
+
+// class LogLevel {
+//   int get LogLevel_Silent => lib!.LogLevel_Silent;
+//   int get LogLevel_0 => lib!.LogLevel_0;
+//   int get LogLevel_1 => lib!.LogLevel_1;
+//   int get LogLevel_2 => lib!.LogLevel_2;
+//   int get LogLevel_3 => lib!.LogLevel_3;
+//   int get LogLevel_4 => lib!.LogLevel_4;
+//   int get LogLevel_Min => LogLevel_Silent;
+//   int get LogLevel_Max => lib!.LogLevel_4;
+// }
+
+// class ConnectionStatus {
+//   int get Disconnected => lib!.WalletConnectionStatus_Disconnected;
+//   int get Connected => lib!.WalletConnectionStatus_Connected;
+//   int get WrongVersion => lib!.WalletConnectionStatus_WrongVersion;
+// }
+
+// DEBUG
+
+class libOk {
+  libOk(
+    this.test1,
+    this.test2,
+    this.test3,
+    this.test4,
+    this.test5,
+    this.test5_std,
+  );
+  final bool test1;
+  final int test2;
+  final int test3;
+  final Pointer<Void> test4;
+  final Pointer<Char> test5;
+  String get test5_str {
+    try {
+      return test5.cast<Utf8>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  String get test5_str16 {
+    try {
+      return test5.cast<Utf16>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  final Pointer<Char> test5_std;
+  String get test5_std_str {
+    try {
+      return test5_std.cast<Utf8>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  String get test5_std_str16 {
+    try {
+      return test5_std.cast<Utf16>().toDartString();
+    } catch (e) {
+      return "$e";
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    return {
+      "test1": test1,
+      "test2": test2,
+      "test3": test3,
+      "test4": test4.toString(),
+      "test5": test5.toString(),
+      "test5_str": test5_str,
+      "test5_std": test5_std.toString(),
+      "test5_std_str": test5_std_str,
+    };
+  }
+}
+
+libOk isLibOk() {
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  lib!.WOWNERO_DEBUG_test0();
+  final test1 = lib!.WOWNERO_DEBUG_test1(true);
+  final test2 = lib!.WOWNERO_DEBUG_test2(-1);
+  final test3 = lib!.WOWNERO_DEBUG_test3(1);
+  final test4 = lib!.WOWNERO_DEBUG_test4(1);
+  final test5 = lib!.WOWNERO_DEBUG_test5();
+  final test5_std = lib!.WOWNERO_DEBUG_test5_std();
+  return libOk(test1, test2, test3, test4, test5, test5_std);
+}
+
+// cake world
+
+typedef WalletListener = Pointer<Void>;
+
+WalletListener WOWNERO_cw_getWalletListener(wallet wptr) {
+  debugStart?.call('WOWNERO_cw_getWalletListener');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_getWalletListener(wptr);
+  debugEnd?.call('WOWNERO_cw_getWalletListener');
+  return s;
+}
+
+void WOWNERO_cw_WalletListener_resetNeedToRefresh(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_resetNeedToRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_resetNeedToRefresh(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_resetNeedToRefresh');
+  return s;
+}
+
+bool WOWNERO_cw_WalletListener_isNeedToRefresh(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_isNeedToRefresh');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_isNeedToRefresh(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_isNeedToRefresh');
+  return s;
+}
+
+bool WOWNERO_cw_WalletListener_isNewTransactionExist(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_isNewTransactionExist');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_isNewTransactionExist(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_isNewTransactionExist');
+  return s;
+}
+
+void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(
+    WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_resetIsNewTransactionExist');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_resetIsNewTransactionExist(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_resetIsNewTransactionExist');
+  return s;
+}
+
+int WOWNERO_cw_WalletListener_height(WalletListener wlptr) {
+  debugStart?.call('WOWNERO_cw_WalletListener_height');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_cw_WalletListener_height(wlptr);
+  debugEnd?.call('WOWNERO_cw_WalletListener_height');
+  return s;
+}
+
+wallet WOWNERO_deprecated_restore14WordSeed({
+  required String path,
+  required String password,
+  required String language,
+  required int networkType,
+}) {
+  debugStart?.call('WOWNERO_deprecated_restore14WordSeed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8();
+  final password_ = password.toNativeUtf8();
+  final language_ = language.toNativeUtf8();
+  final s = lib!.WOWNERO_deprecated_restore14WordSeed(
+      path_.cast(), password_.cast(), language_.cast(), networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_deprecated_restore14WordSeed');
+  return s;
+}
+
+wallet WOWNERO_deprecated_create14WordSeed({
+  required String path,
+  required String password,
+  required String language,
+  required int networkType,
+}) {
+  debugStart?.call('WOWNERO_deprecated_create14WordSeed');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final path_ = path.toNativeUtf8();
+  final password_ = path.toNativeUtf8();
+  final language_ = path.toNativeUtf8();
+  final s = lib!.WOWNERO_deprecated_create14WordSeed(
+      path_.cast(), password_.cast(), language_.cast(), networkType);
+  calloc.free(path_);
+  calloc.free(password_);
+  calloc.free(language_);
+  debugEnd?.call('WOWNERO_deprecated_create14WordSeed');
+  return s;
+}
+
+int WOWNERO_deprecated_14WordSeedHeight({
+  required String seed,
+}) {
+  debugStart?.call('WOWNERO_deprecated_14WordSeedHeight');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+  final seed_ = seed.toNativeUtf8();
+  final s = lib!.WOWNERO_deprecated_14WordSeedHeight(seed_.cast());
+  calloc.free(seed_);
+  debugEnd?.call('WOWNERO_deprecated_14WordSeedHeight');
+  return s;
+}
+
+void WOWNERO_free(Pointer<Void> wlptr) {
+  debugStart?.call('WOWNERO_free');
+  lib ??= WowneroC(DynamicLibrary.open(libPath));
+
+  final s = lib!.WOWNERO_free(wlptr);
+  debugEnd?.call('WOWNERO_free');
+  return s;
+}
diff --git a/impls/monero.dart/monero_wallet2_api_c.h b/impls/monero.dart/monero_wallet2_api_c.h
new file mode 120000
index 0000000..21162b9
--- /dev/null
+++ b/impls/monero.dart/monero_wallet2_api_c.h
@@ -0,0 +1 @@
+../../monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h
\ No newline at end of file
diff --git a/impls/monero.dart/pubspec.yaml b/impls/monero.dart/pubspec.yaml
new file mode 100644
index 0000000..4f48698
--- /dev/null
+++ b/impls/monero.dart/pubspec.yaml
@@ -0,0 +1,15 @@
+name: monero
+description: Dart library for monero
+version: 0.0.0
+repository: https://git.mrcyjanek.net/mrcyjanek/monero.dart
+
+environment:
+  sdk: ^3.0.0
+
+dependencies:
+  ffi: ^2.1.0
+
+dev_dependencies:
+  lints: ^4.0.0
+  test: ^1.24.0
+  ffigen: ^13.0.0
\ No newline at end of file
diff --git a/impls/monero.dart/update_bindings.sh b/impls/monero.dart/update_bindings.sh
new file mode 100755
index 0000000..8ac3cab
--- /dev/null
+++ b/impls/monero.dart/update_bindings.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+set -e
+
+cd "$(realpath $(dirname $0))"
+
+dart run ffigen --config ffigen_wownero.yaml
+dart run ffigen --config ffigen_monero.yaml
diff --git a/impls/monero.dart/wownero_wallet2_api_c.h b/impls/monero.dart/wownero_wallet2_api_c.h
new file mode 120000
index 0000000..3dfff5c
--- /dev/null
+++ b/impls/monero.dart/wownero_wallet2_api_c.h
@@ -0,0 +1 @@
+../../wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h
\ No newline at end of file