From d133a8d8e2c58f05cacd0091ce2c562b199bf0d9 Mon Sep 17 00:00:00 2001 From: Czarek Nakamoto Date: Fri, 26 Jul 2024 15:45:29 +0200 Subject: [PATCH] embed monero.dart into monero_c repository --- .devcontainer/Dockerfile | 18 +- .devcontainer/devcontainer.json | 4 +- .github/workflows/dart_bindings.yaml | 34 + .github/workflows/xmruw.yaml | 1 - impls/monero.dart/.gitignore | 12 + impls/monero.dart/LICENSE | 674 ++ impls/monero.dart/README.md | 74 + impls/monero.dart/analysis_options.yaml | 30 + impls/monero.dart/ffigen_monero.yaml | 11 + impls/monero.dart/ffigen_wownero.yaml | 11 + impls/monero.dart/lib/monero.dart | 3926 ++++++++++++ .../lib/src/generated_bindings_monero.g.dart | 5419 +++++++++++++++++ .../lib/src/generated_bindings_wownero.g.dart | 4980 +++++++++++++++ impls/monero.dart/lib/wownero.dart | 3614 +++++++++++ impls/monero.dart/monero_wallet2_api_c.h | 1 + impls/monero.dart/pubspec.yaml | 15 + impls/monero.dart/update_bindings.sh | 8 + impls/monero.dart/wownero_wallet2_api_c.h | 1 + 18 files changed, 18818 insertions(+), 15 deletions(-) create mode 100644 .github/workflows/dart_bindings.yaml create mode 100644 impls/monero.dart/.gitignore create mode 100644 impls/monero.dart/LICENSE create mode 100644 impls/monero.dart/README.md create mode 100644 impls/monero.dart/analysis_options.yaml create mode 100644 impls/monero.dart/ffigen_monero.yaml create mode 100644 impls/monero.dart/ffigen_wownero.yaml create mode 100644 impls/monero.dart/lib/monero.dart create mode 100644 impls/monero.dart/lib/src/generated_bindings_monero.g.dart create mode 100644 impls/monero.dart/lib/src/generated_bindings_wownero.g.dart create mode 100644 impls/monero.dart/lib/wownero.dart create mode 120000 impls/monero.dart/monero_wallet2_api_c.h create mode 100644 impls/monero.dart/pubspec.yaml create mode 100755 impls/monero.dart/update_bindings.sh create mode 120000 impls/monero.dart/wownero_wallet2_api_c.h diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index a544af01..ad064dbd 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 90a29f40..f6edac10 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 00000000..8d3f5a15 --- /dev/null +++ b/.github/workflows/dart_bindings.yaml @@ -0,0 +1,34 @@ +name: Check if dart bindings are in sync +on: + pull_request: + types: [opened, reopened, synchronize] +permissions: + issues: write + pull-requests: write +jobs: + android: + strategy: + matrix: + coin: [monero, wownero] + 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: Create or update comment + if: failure() + uses: peter-evans/create-or-update-comment@v4 + with: + issue-number: ${{ github.event.pull_request.number }} + body: | + \ No newline at end of file diff --git a/.github/workflows/xmruw.yaml b/.github/workflows/xmruw.yaml index bb862116..e9c9c272 100644 --- a/.github/workflows/xmruw.yaml +++ b/.github/workflows/xmruw.yaml @@ -1,5 +1,4 @@ name: Build xmruw -run-name: Building xmruw for supported targets on: [push] jobs: android: diff --git a/impls/monero.dart/.gitignore b/impls/monero.dart/.gitignore new file mode 100644 index 00000000..0b34a7d3 --- /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 00000000..f288702d --- /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. + 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. + + + Copyright (C) + + 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 . + +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: + + Copyright (C) + 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 +. + + 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 +. diff --git a/impls/monero.dart/README.md b/impls/monero.dart/README.md new file mode 100644 index 00000000..72504e72 --- /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(); +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 00000000..dee8927a --- /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 00000000..3732939b --- /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 00000000..e057fa13 --- /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 00000000..818caf77 --- /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 (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 +// {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 preferredInputs = const []}) { List - 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(); -----------------| Cast the strings into Chars so it can be used as a parameter in a function | +// final payment_id_ = payment_id.toNativeUtf8().cast(); -------------| generated via ffigen | +// final preferredInputs_ = preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast(); <---------------------------------------------------------/ +// 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(); +// 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(); 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; + +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> debugCallLength = {}; + +final defaultSeparatorStr = ";"; +final defaultSeparator = defaultSeparatorStr.toNativeUtf8().cast(); +/* 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] ??= []; + 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(); + 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(); + 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(); + 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(); + final txid = lib!.MONERO_PendingTransaction_txid(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('MONERO_PendingTransaction_txid'); + try { + final strPtr = txid.cast(); + 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(); + final txid = lib!.MONERO_PendingTransaction_subaddrAccount(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('MONERO_PendingTransaction_subaddrAccount'); + try { + final strPtr = txid.cast(); + 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(); + final txid = lib!.MONERO_PendingTransaction_subaddrIndices(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('MONERO_PendingTransaction_subaddrIndices'); + try { + final strPtr = txid.cast(); + 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(); + 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(); + final txid = lib!.MONERO_PendingTransaction_signersKeys(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('MONERO_PendingTransaction_signersKeys'); + try { + final strPtr = txid.cast(); + 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(); + final txid = lib!.MONERO_PendingTransaction_hex(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('MONERO_PendingTransaction_hex'); + try { + final strPtr = txid.cast(); + 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; + +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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + final note_ = note.toNativeUtf8().cast(); + 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; + +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(); + 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(); + 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(); + 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(); + 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; + +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(); + final payment_id_ = paymentId.toNativeUtf8().cast(); + final description_ = description.toNativeUtf8().cast(); + 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(); + 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(); + final v = + lib!.MONERO_AddressBook_lookupPaymentID(addressBook_ptr, paymentId_); + calloc.free(paymentId_); + debugEnd?.call('MONERO_AddressBook_lookupPaymentID'); + return v; +} + +// CoinsInfo +typedef CoinsInfo = Pointer; + +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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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; + +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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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(); + final status = lib!.MONERO_Subaddress_refresh(ptr, accountIndex); + calloc.free(label_); + debugEnd?.call('MONERO_Subaddress_refresh'); + return status; +} + +typedef SubaddressAccountRow = Pointer; + +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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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; + +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; + +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; + +String Wallet_seed(wallet ptr, {required String seedOffset}) { + debugStart?.call('MONERO_Wallet_seed'); + lib ??= MoneroC(DynamicLibrary.open(libPath)); + try { + final seedOffset_ = seedOffset.toNativeUtf8().cast(); + final strPtr = lib!.MONERO_Wallet_seed(ptr, seedOffset_).cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final strPtr = + lib!.MONERO_Wallet_integratedAddress(ptr, paymentId_).cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final daemonUsername_ = daemonUsername.toNativeUtf8().cast(); + final daemonPassword_ = daemonPassword.toNativeUtf8().cast(); + final proxyAddress_ = proxyAddress.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final address_string_ = address_string.toNativeUtf8().cast(); + 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(); + final address_string_ = address_string.toNativeUtf8().cast(); + final strPtr = lib! + .MONERO_Wallet_keyValid_error( + secret_key_string_, address_string_, isViewKey, nettype) + .cast(); + 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(); + final strPtr = + lib!.MONERO_Wallet_paymentIdFromAddress(strarg_, nettype).cast(); + 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(); + final defaultLogBaseName_ = defaultLogBaseName.toNativeUtf8().cast(); + final logPath_ = logPath.toNativeUtf8().cast(); + 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(); + final strPtr = + lib!.MONERO_Wallet_getPolyseed(ptr, passphrase_).cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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 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(); + 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 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(); + 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 Wallet_exportMultisigImages( + wallet ptr, { + required List 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(); + 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 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 dstAddr, + String paymentId = "", + required bool isSweepAll, + required List amounts, + required int mixinCount, + required int pendingTransactionPriority, + required int subaddr_account, + List 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 preferredInputs = const []}) { + debugStart?.call('MONERO_Wallet_createTransaction'); + lib ??= MoneroC(DynamicLibrary.open(libPath)); + + final dst_addr_ = dst_addr.toNativeUtf8().cast(); + final payment_id_ = payment_id.toNativeUtf8().cast(); + final preferredInputs_ = + preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final backgroundCachePassword_ = + backgroundCachePassword.toNativeUtf8().cast(); + 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(); + 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(); + final value_ = value.toNativeUtf8().cast(); + 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(); + final strPtr = lib!.MONERO_Wallet_getCacheAttribute(ptr, key_).cast(); + 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(); + final note_ = note.toNativeUtf8().cast(); + 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(); + final strPtr = lib!.MONERO_Wallet_getUserNote(ptr, txid_).cast(); + 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(); + final strPtr = lib!.MONERO_Wallet_getTxKey(ptr, txid_).cast(); + 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(); + final address_ = address.toNativeUtf8().cast(); + final strPtr = + lib!.MONERO_Wallet_signMessage(ptr, message_, address_).cast(); + 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(); + final address_ = address.toNativeUtf8().cast(); + final signature_ = signature.toNativeUtf8().cast(); + 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(); + 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 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 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 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 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; + +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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final mnemonic_ = mnemonic.toNativeUtf8().cast(); + final seedOffset_ = seedOffset.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + final addressString_ = addressString.toNativeUtf8().cast(); + final viewKeyString_ = viewKeyString.toNativeUtf8().cast(); + final spendKeyString_ = spendKeyString.toNativeUtf8().cast(); + + 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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + final spendKeyString_ = spendKeyString.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final deviceName_ = deviceName.toNativeUtf8().cast(); + final subaddressLookahead_ = subaddressLookahead.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final mnemonic_ = mnemonic.toNativeUtf8().cast(); + final seedOffset_ = seedOffset.toNativeUtf8().cast(); + 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(); + 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(); + final password_ = password.toNativeUtf8().cast(); + 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(); + final strPtr = lib! + .MONERO_WalletManager_findWallets(wm_ptr, path_, defaultSeparator) + .cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + final strPtr = lib! + .MONERO_WalletManager_resolveOpenAlias(wm_ptr, address_, dnssecValid) + .cast(); + 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(); + 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(); + 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 test4; + final Pointer test5; + String get test5_str { + try { + return test5.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + String get test5_str16 { + try { + return test5.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + final Pointer test5_std; + String get test5_std_str { + try { + return test5_std.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + String get test5_std_str16 { + try { + return test5_std.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + Map 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; + +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 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 00000000..59869f40 --- /dev/null +++ b/impls/monero.dart/lib/src/generated_bindings_monero.g.dart @@ -0,0 +1,5419 @@ +// 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 Function(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 Function(String symbolName) + lookup) + : _lookup = lookup; + + int MONERO_PendingTransaction_status( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_status( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_statusPtr = + _lookup)>>( + 'MONERO_PendingTransaction_status'); + late final _MONERO_PendingTransaction_status = + _MONERO_PendingTransaction_statusPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_PendingTransaction_errorString( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_errorString( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_PendingTransaction_errorString'); + late final _MONERO_PendingTransaction_errorString = + _MONERO_PendingTransaction_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + bool MONERO_PendingTransaction_commit( + ffi.Pointer pendingTx_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('MONERO_PendingTransaction_commit'); + late final _MONERO_PendingTransaction_commit = + _MONERO_PendingTransaction_commitPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + ffi.Pointer MONERO_PendingTransaction_commitUR( + ffi.Pointer 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 Function(ffi.Pointer, + ffi.Int)>>('MONERO_PendingTransaction_commitUR'); + late final _MONERO_PendingTransaction_commitUR = + _MONERO_PendingTransaction_commitURPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int MONERO_PendingTransaction_amount( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_amount( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_amountPtr = + _lookup)>>( + 'MONERO_PendingTransaction_amount'); + late final _MONERO_PendingTransaction_amount = + _MONERO_PendingTransaction_amountPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_PendingTransaction_dust( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_dust( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_dustPtr = + _lookup)>>( + 'MONERO_PendingTransaction_dust'); + late final _MONERO_PendingTransaction_dust = + _MONERO_PendingTransaction_dustPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_PendingTransaction_fee( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_fee( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_feePtr = + _lookup)>>( + 'MONERO_PendingTransaction_fee'); + late final _MONERO_PendingTransaction_fee = _MONERO_PendingTransaction_feePtr + .asFunction)>(); + + ffi.Pointer MONERO_PendingTransaction_txid( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_PendingTransaction_txid( + pendingTx_ptr, + separator, + ); + } + + late final _MONERO_PendingTransaction_txidPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_PendingTransaction_txid'); + late final _MONERO_PendingTransaction_txid = + _MONERO_PendingTransaction_txidPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int MONERO_PendingTransaction_txCount( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_txCount( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_txCountPtr = + _lookup)>>( + 'MONERO_PendingTransaction_txCount'); + late final _MONERO_PendingTransaction_txCount = + _MONERO_PendingTransaction_txCountPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_PendingTransaction_subaddrAccount( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_PendingTransaction_subaddrAccount( + pendingTx_ptr, + separator, + ); + } + + late final _MONERO_PendingTransaction_subaddrAccountPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'MONERO_PendingTransaction_subaddrAccount'); + late final _MONERO_PendingTransaction_subaddrAccount = + _MONERO_PendingTransaction_subaddrAccountPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_PendingTransaction_subaddrIndices( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_PendingTransaction_subaddrIndices( + pendingTx_ptr, + separator, + ); + } + + late final _MONERO_PendingTransaction_subaddrIndicesPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'MONERO_PendingTransaction_subaddrIndices'); + late final _MONERO_PendingTransaction_subaddrIndices = + _MONERO_PendingTransaction_subaddrIndicesPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_PendingTransaction_multisigSignData( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_multisigSignData( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_multisigSignDataPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'MONERO_PendingTransaction_multisigSignData'); + late final _MONERO_PendingTransaction_multisigSignData = + _MONERO_PendingTransaction_multisigSignDataPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void MONERO_PendingTransaction_signMultisigTx( + ffi.Pointer pendingTx_ptr, + ) { + return _MONERO_PendingTransaction_signMultisigTx( + pendingTx_ptr, + ); + } + + late final _MONERO_PendingTransaction_signMultisigTxPtr = + _lookup)>>( + 'MONERO_PendingTransaction_signMultisigTx'); + late final _MONERO_PendingTransaction_signMultisigTx = + _MONERO_PendingTransaction_signMultisigTxPtr.asFunction< + void Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_PendingTransaction_signersKeys( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_PendingTransaction_signersKeys( + pendingTx_ptr, + separator, + ); + } + + late final _MONERO_PendingTransaction_signersKeysPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_PendingTransaction_signersKeys'); + late final _MONERO_PendingTransaction_signersKeys = + _MONERO_PendingTransaction_signersKeysPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_PendingTransaction_hex( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_PendingTransaction_hex( + pendingTx_ptr, + separator, + ); + } + + late final _MONERO_PendingTransaction_hexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_PendingTransaction_hex'); + late final _MONERO_PendingTransaction_hex = + _MONERO_PendingTransaction_hexPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int MONERO_UnsignedTransaction_status( + ffi.Pointer unsignedTx_ptr, + ) { + return _MONERO_UnsignedTransaction_status( + unsignedTx_ptr, + ); + } + + late final _MONERO_UnsignedTransaction_statusPtr = + _lookup)>>( + 'MONERO_UnsignedTransaction_status'); + late final _MONERO_UnsignedTransaction_status = + _MONERO_UnsignedTransaction_statusPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_errorString( + ffi.Pointer unsignedTx_ptr, + ) { + return _MONERO_UnsignedTransaction_errorString( + unsignedTx_ptr, + ); + } + + late final _MONERO_UnsignedTransaction_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'MONERO_UnsignedTransaction_errorString'); + late final _MONERO_UnsignedTransaction_errorString = + _MONERO_UnsignedTransaction_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_amount( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_UnsignedTransaction_amount( + unsignedTx_ptr, + separator, + ); + } + + late final _MONERO_UnsignedTransaction_amountPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_UnsignedTransaction_amount'); + late final _MONERO_UnsignedTransaction_amount = + _MONERO_UnsignedTransaction_amountPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_fee( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_UnsignedTransaction_fee( + unsignedTx_ptr, + separator, + ); + } + + late final _MONERO_UnsignedTransaction_feePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_UnsignedTransaction_fee'); + late final _MONERO_UnsignedTransaction_fee = + _MONERO_UnsignedTransaction_feePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_mixin( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_UnsignedTransaction_mixin( + unsignedTx_ptr, + separator, + ); + } + + late final _MONERO_UnsignedTransaction_mixinPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_UnsignedTransaction_mixin'); + late final _MONERO_UnsignedTransaction_mixin = + _MONERO_UnsignedTransaction_mixinPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_confirmationMessage( + ffi.Pointer unsignedTx_ptr, + ) { + return _MONERO_UnsignedTransaction_confirmationMessage( + unsignedTx_ptr, + ); + } + + late final _MONERO_UnsignedTransaction_confirmationMessagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'MONERO_UnsignedTransaction_confirmationMessage'); + late final _MONERO_UnsignedTransaction_confirmationMessage = + _MONERO_UnsignedTransaction_confirmationMessagePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_paymentId( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_UnsignedTransaction_paymentId( + unsignedTx_ptr, + separator, + ); + } + + late final _MONERO_UnsignedTransaction_paymentIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_UnsignedTransaction_paymentId'); + late final _MONERO_UnsignedTransaction_paymentId = + _MONERO_UnsignedTransaction_paymentIdPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_recipientAddress( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _MONERO_UnsignedTransaction_recipientAddress( + unsignedTx_ptr, + separator, + ); + } + + late final _MONERO_UnsignedTransaction_recipientAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'MONERO_UnsignedTransaction_recipientAddress'); + late final _MONERO_UnsignedTransaction_recipientAddress = + _MONERO_UnsignedTransaction_recipientAddressPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int MONERO_UnsignedTransaction_minMixinCount( + ffi.Pointer unsignedTx_ptr, + ) { + return _MONERO_UnsignedTransaction_minMixinCount( + unsignedTx_ptr, + ); + } + + late final _MONERO_UnsignedTransaction_minMixinCountPtr = + _lookup)>>( + 'MONERO_UnsignedTransaction_minMixinCount'); + late final _MONERO_UnsignedTransaction_minMixinCount = + _MONERO_UnsignedTransaction_minMixinCountPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_UnsignedTransaction_txCount( + ffi.Pointer unsignedTx_ptr, + ) { + return _MONERO_UnsignedTransaction_txCount( + unsignedTx_ptr, + ); + } + + late final _MONERO_UnsignedTransaction_txCountPtr = + _lookup)>>( + 'MONERO_UnsignedTransaction_txCount'); + late final _MONERO_UnsignedTransaction_txCount = + _MONERO_UnsignedTransaction_txCountPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_UnsignedTransaction_sign( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer signedFileName, + ) { + return _MONERO_UnsignedTransaction_sign( + unsignedTx_ptr, + signedFileName, + ); + } + + late final _MONERO_UnsignedTransaction_signPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_UnsignedTransaction_sign'); + late final _MONERO_UnsignedTransaction_sign = + _MONERO_UnsignedTransaction_signPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_UnsignedTransaction_signUR( + ffi.Pointer 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 Function(ffi.Pointer, + ffi.Int)>>('MONERO_UnsignedTransaction_signUR'); + late final _MONERO_UnsignedTransaction_signUR = + _MONERO_UnsignedTransaction_signURPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int MONERO_TransactionInfo_direction( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_direction( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_directionPtr = + _lookup)>>( + 'MONERO_TransactionInfo_direction'); + late final _MONERO_TransactionInfo_direction = + _MONERO_TransactionInfo_directionPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_TransactionInfo_isPending( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_isPending( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_isPendingPtr = + _lookup)>>( + 'MONERO_TransactionInfo_isPending'); + late final _MONERO_TransactionInfo_isPending = + _MONERO_TransactionInfo_isPendingPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_TransactionInfo_isFailed( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_isFailed( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_isFailedPtr = + _lookup)>>( + 'MONERO_TransactionInfo_isFailed'); + late final _MONERO_TransactionInfo_isFailed = + _MONERO_TransactionInfo_isFailedPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_TransactionInfo_isCoinbase( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_isCoinbase( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_isCoinbasePtr = + _lookup)>>( + 'MONERO_TransactionInfo_isCoinbase'); + late final _MONERO_TransactionInfo_isCoinbase = + _MONERO_TransactionInfo_isCoinbasePtr.asFunction< + bool Function(ffi.Pointer)>(); + + int MONERO_TransactionInfo_amount( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_amount( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_amountPtr = + _lookup)>>( + 'MONERO_TransactionInfo_amount'); + late final _MONERO_TransactionInfo_amount = _MONERO_TransactionInfo_amountPtr + .asFunction)>(); + + int MONERO_TransactionInfo_fee( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_fee( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_feePtr = + _lookup)>>( + 'MONERO_TransactionInfo_fee'); + late final _MONERO_TransactionInfo_fee = _MONERO_TransactionInfo_feePtr + .asFunction)>(); + + int MONERO_TransactionInfo_blockHeight( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_blockHeight( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_blockHeightPtr = + _lookup)>>( + 'MONERO_TransactionInfo_blockHeight'); + late final _MONERO_TransactionInfo_blockHeight = + _MONERO_TransactionInfo_blockHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_TransactionInfo_description( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_description( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_descriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_TransactionInfo_description'); + late final _MONERO_TransactionInfo_description = + _MONERO_TransactionInfo_descriptionPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_TransactionInfo_subaddrIndex( + ffi.Pointer txInfo_ptr, + ffi.Pointer separator, + ) { + return _MONERO_TransactionInfo_subaddrIndex( + txInfo_ptr, + separator, + ); + } + + late final _MONERO_TransactionInfo_subaddrIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_TransactionInfo_subaddrIndex'); + late final _MONERO_TransactionInfo_subaddrIndex = + _MONERO_TransactionInfo_subaddrIndexPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int MONERO_TransactionInfo_subaddrAccount( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_subaddrAccount( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_subaddrAccountPtr = + _lookup)>>( + 'MONERO_TransactionInfo_subaddrAccount'); + late final _MONERO_TransactionInfo_subaddrAccount = + _MONERO_TransactionInfo_subaddrAccountPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_TransactionInfo_label( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_label( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_labelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_TransactionInfo_label'); + late final _MONERO_TransactionInfo_label = _MONERO_TransactionInfo_labelPtr + .asFunction Function(ffi.Pointer)>(); + + int MONERO_TransactionInfo_confirmations( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_confirmations( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_confirmationsPtr = + _lookup)>>( + 'MONERO_TransactionInfo_confirmations'); + late final _MONERO_TransactionInfo_confirmations = + _MONERO_TransactionInfo_confirmationsPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_TransactionInfo_unlockTime( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_unlockTime( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_unlockTimePtr = + _lookup)>>( + 'MONERO_TransactionInfo_unlockTime'); + late final _MONERO_TransactionInfo_unlockTime = + _MONERO_TransactionInfo_unlockTimePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_TransactionInfo_hash( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_hash( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_hashPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_TransactionInfo_hash'); + late final _MONERO_TransactionInfo_hash = _MONERO_TransactionInfo_hashPtr + .asFunction Function(ffi.Pointer)>(); + + int MONERO_TransactionInfo_timestamp( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_timestamp( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_timestampPtr = + _lookup)>>( + 'MONERO_TransactionInfo_timestamp'); + late final _MONERO_TransactionInfo_timestamp = + _MONERO_TransactionInfo_timestampPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_TransactionInfo_paymentId( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_paymentId( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_paymentIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_TransactionInfo_paymentId'); + late final _MONERO_TransactionInfo_paymentId = + _MONERO_TransactionInfo_paymentIdPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_TransactionInfo_transfers_count( + ffi.Pointer txInfo_ptr, + ) { + return _MONERO_TransactionInfo_transfers_count( + txInfo_ptr, + ); + } + + late final _MONERO_TransactionInfo_transfers_countPtr = + _lookup)>>( + 'MONERO_TransactionInfo_transfers_count'); + late final _MONERO_TransactionInfo_transfers_count = + _MONERO_TransactionInfo_transfers_countPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_TransactionInfo_transfers_amount( + ffi.Pointer txInfo_ptr, + int index, + ) { + return _MONERO_TransactionInfo_transfers_amount( + txInfo_ptr, + index, + ); + } + + late final _MONERO_TransactionInfo_transfers_amountPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'MONERO_TransactionInfo_transfers_amount'); + late final _MONERO_TransactionInfo_transfers_amount = + _MONERO_TransactionInfo_transfers_amountPtr.asFunction< + int Function(ffi.Pointer, int)>(); + + ffi.Pointer MONERO_TransactionInfo_transfers_address( + ffi.Pointer txInfo_ptr, + int address, + ) { + return _MONERO_TransactionInfo_transfers_address( + txInfo_ptr, + address, + ); + } + + late final _MONERO_TransactionInfo_transfers_addressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('MONERO_TransactionInfo_transfers_address'); + late final _MONERO_TransactionInfo_transfers_address = + _MONERO_TransactionInfo_transfers_addressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int MONERO_TransactionHistory_count( + ffi.Pointer txHistory_ptr, + ) { + return _MONERO_TransactionHistory_count( + txHistory_ptr, + ); + } + + late final _MONERO_TransactionHistory_countPtr = + _lookup)>>( + 'MONERO_TransactionHistory_count'); + late final _MONERO_TransactionHistory_count = + _MONERO_TransactionHistory_countPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_TransactionHistory_transaction( + ffi.Pointer txHistory_ptr, + int index, + ) { + return _MONERO_TransactionHistory_transaction( + txHistory_ptr, + index, + ); + } + + late final _MONERO_TransactionHistory_transactionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('MONERO_TransactionHistory_transaction'); + late final _MONERO_TransactionHistory_transaction = + _MONERO_TransactionHistory_transactionPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + ffi.Pointer MONERO_TransactionHistory_transactionById( + ffi.Pointer txHistory_ptr, + ffi.Pointer id, + ) { + return _MONERO_TransactionHistory_transactionById( + txHistory_ptr, + id, + ); + } + + late final _MONERO_TransactionHistory_transactionByIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'MONERO_TransactionHistory_transactionById'); + late final _MONERO_TransactionHistory_transactionById = + _MONERO_TransactionHistory_transactionByIdPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + void MONERO_TransactionHistory_refresh( + ffi.Pointer txHistory_ptr, + ) { + return _MONERO_TransactionHistory_refresh( + txHistory_ptr, + ); + } + + late final _MONERO_TransactionHistory_refreshPtr = + _lookup)>>( + 'MONERO_TransactionHistory_refresh'); + late final _MONERO_TransactionHistory_refresh = + _MONERO_TransactionHistory_refreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + void MONERO_TransactionHistory_setTxNote( + ffi.Pointer txHistory_ptr, + ffi.Pointer txid, + ffi.Pointer note, + ) { + return _MONERO_TransactionHistory_setTxNote( + txHistory_ptr, + txid, + note, + ); + } + + late final _MONERO_TransactionHistory_setTxNotePtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('MONERO_TransactionHistory_setTxNote'); + late final _MONERO_TransactionHistory_setTxNote = + _MONERO_TransactionHistory_setTxNotePtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer MONERO_AddressBookRow_extra( + ffi.Pointer addressBookRow_ptr, + ) { + return _MONERO_AddressBookRow_extra( + addressBookRow_ptr, + ); + } + + late final _MONERO_AddressBookRow_extraPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_AddressBookRow_extra'); + late final _MONERO_AddressBookRow_extra = _MONERO_AddressBookRow_extraPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_AddressBookRow_getAddress( + ffi.Pointer addressBookRow_ptr, + ) { + return _MONERO_AddressBookRow_getAddress( + addressBookRow_ptr, + ); + } + + late final _MONERO_AddressBookRow_getAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_AddressBookRow_getAddress'); + late final _MONERO_AddressBookRow_getAddress = + _MONERO_AddressBookRow_getAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_AddressBookRow_getDescription( + ffi.Pointer addressBookRow_ptr, + ) { + return _MONERO_AddressBookRow_getDescription( + addressBookRow_ptr, + ); + } + + late final _MONERO_AddressBookRow_getDescriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_AddressBookRow_getDescription'); + late final _MONERO_AddressBookRow_getDescription = + _MONERO_AddressBookRow_getDescriptionPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_AddressBookRow_getPaymentId( + ffi.Pointer addressBookRow_ptr, + ) { + return _MONERO_AddressBookRow_getPaymentId( + addressBookRow_ptr, + ); + } + + late final _MONERO_AddressBookRow_getPaymentIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_AddressBookRow_getPaymentId'); + late final _MONERO_AddressBookRow_getPaymentId = + _MONERO_AddressBookRow_getPaymentIdPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_AddressBookRow_getRowId( + ffi.Pointer addressBookRow_ptr, + ) { + return _MONERO_AddressBookRow_getRowId( + addressBookRow_ptr, + ); + } + + late final _MONERO_AddressBookRow_getRowIdPtr = + _lookup)>>( + 'MONERO_AddressBookRow_getRowId'); + late final _MONERO_AddressBookRow_getRowId = + _MONERO_AddressBookRow_getRowIdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_AddressBook_getAll_size( + ffi.Pointer addressBook_ptr, + ) { + return _MONERO_AddressBook_getAll_size( + addressBook_ptr, + ); + } + + late final _MONERO_AddressBook_getAll_sizePtr = + _lookup)>>( + 'MONERO_AddressBook_getAll_size'); + late final _MONERO_AddressBook_getAll_size = + _MONERO_AddressBook_getAll_sizePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_AddressBook_getAll_byIndex( + ffi.Pointer addressBook_ptr, + int index, + ) { + return _MONERO_AddressBook_getAll_byIndex( + addressBook_ptr, + index, + ); + } + + late final _MONERO_AddressBook_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('MONERO_AddressBook_getAll_byIndex'); + late final _MONERO_AddressBook_getAll_byIndex = + _MONERO_AddressBook_getAll_byIndexPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + bool MONERO_AddressBook_addRow( + ffi.Pointer addressBook_ptr, + ffi.Pointer dst_addr, + ffi.Pointer payment_id, + ffi.Pointer 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.Pointer, + ffi.Pointer, + ffi.Pointer)>>('MONERO_AddressBook_addRow'); + late final _MONERO_AddressBook_addRow = + _MONERO_AddressBook_addRowPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_AddressBook_deleteRow( + ffi.Pointer addressBook_ptr, + int rowId, + ) { + return _MONERO_AddressBook_deleteRow( + addressBook_ptr, + rowId, + ); + } + + late final _MONERO_AddressBook_deleteRowPtr = _lookup< + ffi + .NativeFunction, ffi.Size)>>( + 'MONERO_AddressBook_deleteRow'); + late final _MONERO_AddressBook_deleteRow = _MONERO_AddressBook_deleteRowPtr + .asFunction, int)>(); + + bool MONERO_AddressBook_setDescription( + ffi.Pointer addressBook_ptr, + int rowId, + ffi.Pointer description, + ) { + return _MONERO_AddressBook_setDescription( + addressBook_ptr, + rowId, + description, + ); + } + + late final _MONERO_AddressBook_setDescriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, ffi.Size, + ffi.Pointer)>>('MONERO_AddressBook_setDescription'); + late final _MONERO_AddressBook_setDescription = + _MONERO_AddressBook_setDescriptionPtr.asFunction< + bool Function(ffi.Pointer, int, ffi.Pointer)>(); + + void MONERO_AddressBook_refresh( + ffi.Pointer addressBook_ptr, + ) { + return _MONERO_AddressBook_refresh( + addressBook_ptr, + ); + } + + late final _MONERO_AddressBook_refreshPtr = + _lookup)>>( + 'MONERO_AddressBook_refresh'); + late final _MONERO_AddressBook_refresh = _MONERO_AddressBook_refreshPtr + .asFunction)>(); + + ffi.Pointer MONERO_AddressBook_errorString( + ffi.Pointer addressBook_ptr, + ) { + return _MONERO_AddressBook_errorString( + addressBook_ptr, + ); + } + + late final _MONERO_AddressBook_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_AddressBook_errorString'); + late final _MONERO_AddressBook_errorString = + _MONERO_AddressBook_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_AddressBook_errorCode( + ffi.Pointer addressBook_ptr, + ) { + return _MONERO_AddressBook_errorCode( + addressBook_ptr, + ); + } + + late final _MONERO_AddressBook_errorCodePtr = + _lookup)>>( + 'MONERO_AddressBook_errorCode'); + late final _MONERO_AddressBook_errorCode = _MONERO_AddressBook_errorCodePtr + .asFunction)>(); + + int MONERO_AddressBook_lookupPaymentID( + ffi.Pointer addressBook_ptr, + ffi.Pointer payment_id, + ) { + return _MONERO_AddressBook_lookupPaymentID( + addressBook_ptr, + payment_id, + ); + } + + late final _MONERO_AddressBook_lookupPaymentIDPtr = _lookup< + ffi.NativeFunction< + ffi.Int Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_AddressBook_lookupPaymentID'); + late final _MONERO_AddressBook_lookupPaymentID = + _MONERO_AddressBook_lookupPaymentIDPtr.asFunction< + int Function(ffi.Pointer, ffi.Pointer)>(); + + int MONERO_CoinsInfo_blockHeight( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_blockHeight( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_blockHeightPtr = + _lookup)>>( + 'MONERO_CoinsInfo_blockHeight'); + late final _MONERO_CoinsInfo_blockHeight = _MONERO_CoinsInfo_blockHeightPtr + .asFunction)>(); + + ffi.Pointer MONERO_CoinsInfo_hash( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_hash( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_hashPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_CoinsInfo_hash'); + late final _MONERO_CoinsInfo_hash = _MONERO_CoinsInfo_hashPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_CoinsInfo_internalOutputIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_internalOutputIndex( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_internalOutputIndexPtr = + _lookup)>>( + 'MONERO_CoinsInfo_internalOutputIndex'); + late final _MONERO_CoinsInfo_internalOutputIndex = + _MONERO_CoinsInfo_internalOutputIndexPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_CoinsInfo_globalOutputIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_globalOutputIndex( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_globalOutputIndexPtr = + _lookup)>>( + 'MONERO_CoinsInfo_globalOutputIndex'); + late final _MONERO_CoinsInfo_globalOutputIndex = + _MONERO_CoinsInfo_globalOutputIndexPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_CoinsInfo_spent( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_spent( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_spentPtr = + _lookup)>>( + 'MONERO_CoinsInfo_spent'); + late final _MONERO_CoinsInfo_spent = _MONERO_CoinsInfo_spentPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_CoinsInfo_frozen( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_frozen( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_frozenPtr = + _lookup)>>( + 'MONERO_CoinsInfo_frozen'); + late final _MONERO_CoinsInfo_frozen = _MONERO_CoinsInfo_frozenPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int MONERO_CoinsInfo_spentHeight( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_spentHeight( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_spentHeightPtr = + _lookup)>>( + 'MONERO_CoinsInfo_spentHeight'); + late final _MONERO_CoinsInfo_spentHeight = _MONERO_CoinsInfo_spentHeightPtr + .asFunction)>(); + + int MONERO_CoinsInfo_amount( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_amount( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_amountPtr = + _lookup)>>( + 'MONERO_CoinsInfo_amount'); + late final _MONERO_CoinsInfo_amount = _MONERO_CoinsInfo_amountPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_CoinsInfo_rct( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_rct( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_rctPtr = + _lookup)>>( + 'MONERO_CoinsInfo_rct'); + late final _MONERO_CoinsInfo_rct = _MONERO_CoinsInfo_rctPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_CoinsInfo_keyImageKnown( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_keyImageKnown( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_keyImageKnownPtr = + _lookup)>>( + 'MONERO_CoinsInfo_keyImageKnown'); + late final _MONERO_CoinsInfo_keyImageKnown = + _MONERO_CoinsInfo_keyImageKnownPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int MONERO_CoinsInfo_pkIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_pkIndex( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_pkIndexPtr = + _lookup)>>( + 'MONERO_CoinsInfo_pkIndex'); + late final _MONERO_CoinsInfo_pkIndex = _MONERO_CoinsInfo_pkIndexPtr + .asFunction)>(); + + int MONERO_CoinsInfo_subaddrIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_subaddrIndex( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_subaddrIndexPtr = + _lookup)>>( + 'MONERO_CoinsInfo_subaddrIndex'); + late final _MONERO_CoinsInfo_subaddrIndex = _MONERO_CoinsInfo_subaddrIndexPtr + .asFunction)>(); + + int MONERO_CoinsInfo_subaddrAccount( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_subaddrAccount( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_subaddrAccountPtr = + _lookup)>>( + 'MONERO_CoinsInfo_subaddrAccount'); + late final _MONERO_CoinsInfo_subaddrAccount = + _MONERO_CoinsInfo_subaddrAccountPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_CoinsInfo_address( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_address( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_addressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_CoinsInfo_address'); + late final _MONERO_CoinsInfo_address = _MONERO_CoinsInfo_addressPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_CoinsInfo_addressLabel( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_addressLabel( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_addressLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_CoinsInfo_addressLabel'); + late final _MONERO_CoinsInfo_addressLabel = _MONERO_CoinsInfo_addressLabelPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_CoinsInfo_keyImage( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_keyImage( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_keyImagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_CoinsInfo_keyImage'); + late final _MONERO_CoinsInfo_keyImage = _MONERO_CoinsInfo_keyImagePtr + .asFunction Function(ffi.Pointer)>(); + + int MONERO_CoinsInfo_unlockTime( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_unlockTime( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_unlockTimePtr = + _lookup)>>( + 'MONERO_CoinsInfo_unlockTime'); + late final _MONERO_CoinsInfo_unlockTime = _MONERO_CoinsInfo_unlockTimePtr + .asFunction)>(); + + bool MONERO_CoinsInfo_unlocked( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_unlocked( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_unlockedPtr = + _lookup)>>( + 'MONERO_CoinsInfo_unlocked'); + late final _MONERO_CoinsInfo_unlocked = _MONERO_CoinsInfo_unlockedPtr + .asFunction)>(); + + ffi.Pointer MONERO_CoinsInfo_pubKey( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_pubKey( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_pubKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_CoinsInfo_pubKey'); + late final _MONERO_CoinsInfo_pubKey = _MONERO_CoinsInfo_pubKeyPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + bool MONERO_CoinsInfo_coinbase( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_coinbase( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_coinbasePtr = + _lookup)>>( + 'MONERO_CoinsInfo_coinbase'); + late final _MONERO_CoinsInfo_coinbase = _MONERO_CoinsInfo_coinbasePtr + .asFunction)>(); + + ffi.Pointer MONERO_CoinsInfo_description( + ffi.Pointer coinsInfo_ptr, + ) { + return _MONERO_CoinsInfo_description( + coinsInfo_ptr, + ); + } + + late final _MONERO_CoinsInfo_descriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_CoinsInfo_description'); + late final _MONERO_CoinsInfo_description = _MONERO_CoinsInfo_descriptionPtr + .asFunction Function(ffi.Pointer)>(); + + int MONERO_Coins_count( + ffi.Pointer coins_ptr, + ) { + return _MONERO_Coins_count( + coins_ptr, + ); + } + + late final _MONERO_Coins_countPtr = + _lookup)>>( + 'MONERO_Coins_count'); + late final _MONERO_Coins_count = + _MONERO_Coins_countPtr.asFunction)>(); + + ffi.Pointer MONERO_Coins_coin( + ffi.Pointer coins_ptr, + int index, + ) { + return _MONERO_Coins_coin( + coins_ptr, + index, + ); + } + + late final _MONERO_Coins_coinPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Int)>>('MONERO_Coins_coin'); + late final _MONERO_Coins_coin = _MONERO_Coins_coinPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int MONERO_Coins_getAll_size( + ffi.Pointer coins_ptr, + ) { + return _MONERO_Coins_getAll_size( + coins_ptr, + ); + } + + late final _MONERO_Coins_getAll_sizePtr = + _lookup)>>( + 'MONERO_Coins_getAll_size'); + late final _MONERO_Coins_getAll_size = _MONERO_Coins_getAll_sizePtr + .asFunction)>(); + + ffi.Pointer MONERO_Coins_getAll_byIndex( + ffi.Pointer coins_ptr, + int index, + ) { + return _MONERO_Coins_getAll_byIndex( + coins_ptr, + index, + ); + } + + late final _MONERO_Coins_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Int)>>('MONERO_Coins_getAll_byIndex'); + late final _MONERO_Coins_getAll_byIndex = _MONERO_Coins_getAll_byIndexPtr + .asFunction Function(ffi.Pointer, int)>(); + + void MONERO_Coins_refresh( + ffi.Pointer coins_ptr, + ) { + return _MONERO_Coins_refresh( + coins_ptr, + ); + } + + late final _MONERO_Coins_refreshPtr = + _lookup)>>( + 'MONERO_Coins_refresh'); + late final _MONERO_Coins_refresh = _MONERO_Coins_refreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + void MONERO_Coins_setFrozenByPublicKey( + ffi.Pointer coins_ptr, + ffi.Pointer public_key, + ) { + return _MONERO_Coins_setFrozenByPublicKey( + coins_ptr, + public_key, + ); + } + + late final _MONERO_Coins_setFrozenByPublicKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Coins_setFrozenByPublicKey'); + late final _MONERO_Coins_setFrozenByPublicKey = + _MONERO_Coins_setFrozenByPublicKeyPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + void MONERO_Coins_setFrozen( + ffi.Pointer coins_ptr, + int index, + ) { + return _MONERO_Coins_setFrozen( + coins_ptr, + index, + ); + } + + late final _MONERO_Coins_setFrozenPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'MONERO_Coins_setFrozen'); + late final _MONERO_Coins_setFrozen = _MONERO_Coins_setFrozenPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + void MONERO_Coins_thaw( + ffi.Pointer coins_ptr, + int index, + ) { + return _MONERO_Coins_thaw( + coins_ptr, + index, + ); + } + + late final _MONERO_Coins_thawPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'MONERO_Coins_thaw'); + late final _MONERO_Coins_thaw = _MONERO_Coins_thawPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + void MONERO_Coins_thawByPublicKey( + ffi.Pointer coins_ptr, + ffi.Pointer public_key, + ) { + return _MONERO_Coins_thawByPublicKey( + coins_ptr, + public_key, + ); + } + + late final _MONERO_Coins_thawByPublicKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Coins_thawByPublicKey'); + late final _MONERO_Coins_thawByPublicKey = + _MONERO_Coins_thawByPublicKeyPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Coins_isTransferUnlocked( + ffi.Pointer 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.Uint64, + ffi.Uint64)>>('MONERO_Coins_isTransferUnlocked'); + late final _MONERO_Coins_isTransferUnlocked = + _MONERO_Coins_isTransferUnlockedPtr.asFunction< + bool Function(ffi.Pointer, int, int)>(); + + void MONERO_Coins_setDescription( + ffi.Pointer coins_ptr, + ffi.Pointer public_key, + ffi.Pointer description, + ) { + return _MONERO_Coins_setDescription( + coins_ptr, + public_key, + description, + ); + } + + late final _MONERO_Coins_setDescriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('MONERO_Coins_setDescription'); + late final _MONERO_Coins_setDescription = + _MONERO_Coins_setDescriptionPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressRow_extra( + ffi.Pointer subaddressRow_ptr, + ) { + return _MONERO_SubaddressRow_extra( + subaddressRow_ptr, + ); + } + + late final _MONERO_SubaddressRow_extraPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_SubaddressRow_extra'); + late final _MONERO_SubaddressRow_extra = _MONERO_SubaddressRow_extraPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressRow_getAddress( + ffi.Pointer subaddressRow_ptr, + ) { + return _MONERO_SubaddressRow_getAddress( + subaddressRow_ptr, + ); + } + + late final _MONERO_SubaddressRow_getAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_SubaddressRow_getAddress'); + late final _MONERO_SubaddressRow_getAddress = + _MONERO_SubaddressRow_getAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressRow_getLabel( + ffi.Pointer subaddressRow_ptr, + ) { + return _MONERO_SubaddressRow_getLabel( + subaddressRow_ptr, + ); + } + + late final _MONERO_SubaddressRow_getLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_SubaddressRow_getLabel'); + late final _MONERO_SubaddressRow_getLabel = _MONERO_SubaddressRow_getLabelPtr + .asFunction Function(ffi.Pointer)>(); + + int MONERO_SubaddressRow_getRowId( + ffi.Pointer subaddressRow_ptr, + ) { + return _MONERO_SubaddressRow_getRowId( + subaddressRow_ptr, + ); + } + + late final _MONERO_SubaddressRow_getRowIdPtr = + _lookup)>>( + 'MONERO_SubaddressRow_getRowId'); + late final _MONERO_SubaddressRow_getRowId = _MONERO_SubaddressRow_getRowIdPtr + .asFunction)>(); + + int MONERO_Subaddress_getAll_size( + ffi.Pointer subaddress_ptr, + ) { + return _MONERO_Subaddress_getAll_size( + subaddress_ptr, + ); + } + + late final _MONERO_Subaddress_getAll_sizePtr = + _lookup)>>( + 'MONERO_Subaddress_getAll_size'); + late final _MONERO_Subaddress_getAll_size = _MONERO_Subaddress_getAll_sizePtr + .asFunction)>(); + + ffi.Pointer MONERO_Subaddress_getAll_byIndex( + ffi.Pointer subaddress_ptr, + int index, + ) { + return _MONERO_Subaddress_getAll_byIndex( + subaddress_ptr, + index, + ); + } + + late final _MONERO_Subaddress_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('MONERO_Subaddress_getAll_byIndex'); + late final _MONERO_Subaddress_getAll_byIndex = + _MONERO_Subaddress_getAll_byIndexPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + void MONERO_Subaddress_addRow( + ffi.Pointer subaddress_ptr, + int accountIndex, + ffi.Pointer label, + ) { + return _MONERO_Subaddress_addRow( + subaddress_ptr, + accountIndex, + label, + ); + } + + late final _MONERO_Subaddress_addRowPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, + ffi.Pointer)>>('MONERO_Subaddress_addRow'); + late final _MONERO_Subaddress_addRow = + _MONERO_Subaddress_addRowPtr.asFunction< + void Function(ffi.Pointer, int, ffi.Pointer)>(); + + void MONERO_Subaddress_setLabel( + ffi.Pointer subaddress_ptr, + int accountIndex, + int addressIndex, + ffi.Pointer label, + ) { + return _MONERO_Subaddress_setLabel( + subaddress_ptr, + accountIndex, + addressIndex, + label, + ); + } + + late final _MONERO_Subaddress_setLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, ffi.Uint32, + ffi.Pointer)>>('MONERO_Subaddress_setLabel'); + late final _MONERO_Subaddress_setLabel = + _MONERO_Subaddress_setLabelPtr.asFunction< + void Function( + ffi.Pointer, int, int, ffi.Pointer)>(); + + void MONERO_Subaddress_refresh( + ffi.Pointer 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.Uint32)>>('MONERO_Subaddress_refresh'); + late final _MONERO_Subaddress_refresh = _MONERO_Subaddress_refreshPtr + .asFunction, int)>(); + + ffi.Pointer MONERO_SubaddressAccountRow_extra( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _MONERO_SubaddressAccountRow_extra( + subaddressAccountRow_ptr, + ); + } + + late final _MONERO_SubaddressAccountRow_extraPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_SubaddressAccountRow_extra'); + late final _MONERO_SubaddressAccountRow_extra = + _MONERO_SubaddressAccountRow_extraPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressAccountRow_getAddress( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _MONERO_SubaddressAccountRow_getAddress( + subaddressAccountRow_ptr, + ); + } + + late final _MONERO_SubaddressAccountRow_getAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'MONERO_SubaddressAccountRow_getAddress'); + late final _MONERO_SubaddressAccountRow_getAddress = + _MONERO_SubaddressAccountRow_getAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressAccountRow_getLabel( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _MONERO_SubaddressAccountRow_getLabel( + subaddressAccountRow_ptr, + ); + } + + late final _MONERO_SubaddressAccountRow_getLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_SubaddressAccountRow_getLabel'); + late final _MONERO_SubaddressAccountRow_getLabel = + _MONERO_SubaddressAccountRow_getLabelPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressAccountRow_getBalance( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _MONERO_SubaddressAccountRow_getBalance( + subaddressAccountRow_ptr, + ); + } + + late final _MONERO_SubaddressAccountRow_getBalancePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'MONERO_SubaddressAccountRow_getBalance'); + late final _MONERO_SubaddressAccountRow_getBalance = + _MONERO_SubaddressAccountRow_getBalancePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressAccountRow_getUnlockedBalance( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _MONERO_SubaddressAccountRow_getUnlockedBalance( + subaddressAccountRow_ptr, + ); + } + + late final _MONERO_SubaddressAccountRow_getUnlockedBalancePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'MONERO_SubaddressAccountRow_getUnlockedBalance'); + late final _MONERO_SubaddressAccountRow_getUnlockedBalance = + _MONERO_SubaddressAccountRow_getUnlockedBalancePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_SubaddressAccountRow_getRowId( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _MONERO_SubaddressAccountRow_getRowId( + subaddressAccountRow_ptr, + ); + } + + late final _MONERO_SubaddressAccountRow_getRowIdPtr = + _lookup)>>( + 'MONERO_SubaddressAccountRow_getRowId'); + late final _MONERO_SubaddressAccountRow_getRowId = + _MONERO_SubaddressAccountRow_getRowIdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_SubaddressAccount_getAll_size( + ffi.Pointer subaddressAccount_ptr, + ) { + return _MONERO_SubaddressAccount_getAll_size( + subaddressAccount_ptr, + ); + } + + late final _MONERO_SubaddressAccount_getAll_sizePtr = + _lookup)>>( + 'MONERO_SubaddressAccount_getAll_size'); + late final _MONERO_SubaddressAccount_getAll_size = + _MONERO_SubaddressAccount_getAll_sizePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_SubaddressAccount_getAll_byIndex( + ffi.Pointer subaddressAccount_ptr, + int index, + ) { + return _MONERO_SubaddressAccount_getAll_byIndex( + subaddressAccount_ptr, + index, + ); + } + + late final _MONERO_SubaddressAccount_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('MONERO_SubaddressAccount_getAll_byIndex'); + late final _MONERO_SubaddressAccount_getAll_byIndex = + _MONERO_SubaddressAccount_getAll_byIndexPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + void MONERO_SubaddressAccount_addRow( + ffi.Pointer subaddressAccount_ptr, + ffi.Pointer label, + ) { + return _MONERO_SubaddressAccount_addRow( + subaddressAccount_ptr, + label, + ); + } + + late final _MONERO_SubaddressAccount_addRowPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_SubaddressAccount_addRow'); + late final _MONERO_SubaddressAccount_addRow = + _MONERO_SubaddressAccount_addRowPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + void MONERO_SubaddressAccount_setLabel( + ffi.Pointer subaddressAccount_ptr, + int accountIndex, + ffi.Pointer label, + ) { + return _MONERO_SubaddressAccount_setLabel( + subaddressAccount_ptr, + accountIndex, + label, + ); + } + + late final _MONERO_SubaddressAccount_setLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, + ffi.Pointer)>>('MONERO_SubaddressAccount_setLabel'); + late final _MONERO_SubaddressAccount_setLabel = + _MONERO_SubaddressAccount_setLabelPtr.asFunction< + void Function(ffi.Pointer, int, ffi.Pointer)>(); + + void MONERO_SubaddressAccount_refresh( + ffi.Pointer subaddressAccount_ptr, + ) { + return _MONERO_SubaddressAccount_refresh( + subaddressAccount_ptr, + ); + } + + late final _MONERO_SubaddressAccount_refreshPtr = + _lookup)>>( + 'MONERO_SubaddressAccount_refresh'); + late final _MONERO_SubaddressAccount_refresh = + _MONERO_SubaddressAccount_refreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + bool MONERO_MultisigState_isMultisig( + ffi.Pointer multisigState_ptr, + ) { + return _MONERO_MultisigState_isMultisig( + multisigState_ptr, + ); + } + + late final _MONERO_MultisigState_isMultisigPtr = + _lookup)>>( + 'MONERO_MultisigState_isMultisig'); + late final _MONERO_MultisigState_isMultisig = + _MONERO_MultisigState_isMultisigPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_MultisigState_isReady( + ffi.Pointer multisigState_ptr, + ) { + return _MONERO_MultisigState_isReady( + multisigState_ptr, + ); + } + + late final _MONERO_MultisigState_isReadyPtr = + _lookup)>>( + 'MONERO_MultisigState_isReady'); + late final _MONERO_MultisigState_isReady = _MONERO_MultisigState_isReadyPtr + .asFunction)>(); + + int MONERO_MultisigState_threshold( + ffi.Pointer multisigState_ptr, + ) { + return _MONERO_MultisigState_threshold( + multisigState_ptr, + ); + } + + late final _MONERO_MultisigState_thresholdPtr = + _lookup)>>( + 'MONERO_MultisigState_threshold'); + late final _MONERO_MultisigState_threshold = + _MONERO_MultisigState_thresholdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_MultisigState_total( + ffi.Pointer multisigState_ptr, + ) { + return _MONERO_MultisigState_total( + multisigState_ptr, + ); + } + + late final _MONERO_MultisigState_totalPtr = + _lookup)>>( + 'MONERO_MultisigState_total'); + late final _MONERO_MultisigState_total = _MONERO_MultisigState_totalPtr + .asFunction)>(); + + bool MONERO_DeviceProgress_progress( + ffi.Pointer deviceProgress_ptr, + ) { + return _MONERO_DeviceProgress_progress( + deviceProgress_ptr, + ); + } + + late final _MONERO_DeviceProgress_progressPtr = + _lookup)>>( + 'MONERO_DeviceProgress_progress'); + late final _MONERO_DeviceProgress_progress = + _MONERO_DeviceProgress_progressPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_DeviceProgress_indeterminate( + ffi.Pointer deviceProgress_ptr, + ) { + return _MONERO_DeviceProgress_indeterminate( + deviceProgress_ptr, + ); + } + + late final _MONERO_DeviceProgress_indeterminatePtr = + _lookup)>>( + 'MONERO_DeviceProgress_indeterminate'); + late final _MONERO_DeviceProgress_indeterminate = + _MONERO_DeviceProgress_indeterminatePtr.asFunction< + bool Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_seed( + ffi.Pointer wallet_ptr, + ffi.Pointer seed_offset, + ) { + return _MONERO_Wallet_seed( + wallet_ptr, + seed_offset, + ); + } + + late final _MONERO_Wallet_seedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_seed'); + late final _MONERO_Wallet_seed = _MONERO_Wallet_seedPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getSeedLanguage( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getSeedLanguage( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getSeedLanguagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_getSeedLanguage'); + late final _MONERO_Wallet_getSeedLanguage = _MONERO_Wallet_getSeedLanguagePtr + .asFunction Function(ffi.Pointer)>(); + + void MONERO_Wallet_setSeedLanguage( + ffi.Pointer wallet_ptr, + ffi.Pointer arg, + ) { + return _MONERO_Wallet_setSeedLanguage( + wallet_ptr, + arg, + ); + } + + late final _MONERO_Wallet_setSeedLanguagePtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setSeedLanguage'); + late final _MONERO_Wallet_setSeedLanguage = + _MONERO_Wallet_setSeedLanguagePtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + int MONERO_Wallet_status( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_status( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_statusPtr = + _lookup)>>( + 'MONERO_Wallet_status'); + late final _MONERO_Wallet_status = _MONERO_Wallet_statusPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_errorString( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_errorString( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_errorString'); + late final _MONERO_Wallet_errorString = _MONERO_Wallet_errorStringPtr + .asFunction Function(ffi.Pointer)>(); + + bool MONERO_Wallet_setPassword( + ffi.Pointer wallet_ptr, + ffi.Pointer password, + ) { + return _MONERO_Wallet_setPassword( + wallet_ptr, + password, + ); + } + + late final _MONERO_Wallet_setPasswordPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setPassword'); + late final _MONERO_Wallet_setPassword = + _MONERO_Wallet_setPasswordPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getPassword( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getPassword( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getPasswordPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_getPassword'); + late final _MONERO_Wallet_getPassword = _MONERO_Wallet_getPasswordPtr + .asFunction Function(ffi.Pointer)>(); + + bool MONERO_Wallet_setDevicePin( + ffi.Pointer wallet_ptr, + ffi.Pointer pin, + ) { + return _MONERO_Wallet_setDevicePin( + wallet_ptr, + pin, + ); + } + + late final _MONERO_Wallet_setDevicePinPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setDevicePin'); + late final _MONERO_Wallet_setDevicePin = + _MONERO_Wallet_setDevicePinPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_setDevicePassphrase( + ffi.Pointer wallet_ptr, + ffi.Pointer passphrase, + ) { + return _MONERO_Wallet_setDevicePassphrase( + wallet_ptr, + passphrase, + ); + } + + late final _MONERO_Wallet_setDevicePassphrasePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setDevicePassphrase'); + late final _MONERO_Wallet_setDevicePassphrase = + _MONERO_Wallet_setDevicePassphrasePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_address( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ) { + return _MONERO_Wallet_address( + wallet_ptr, + accountIndex, + addressIndex, + ); + } + + late final _MONERO_Wallet_addressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, ffi.Uint64, + ffi.Uint64)>>('MONERO_Wallet_address'); + late final _MONERO_Wallet_address = _MONERO_Wallet_addressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, int)>(); + + ffi.Pointer MONERO_Wallet_path( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_path( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_pathPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_path'); + late final _MONERO_Wallet_path = _MONERO_Wallet_pathPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_Wallet_nettype( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_nettype( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_nettypePtr = + _lookup)>>( + 'MONERO_Wallet_nettype'); + late final _MONERO_Wallet_nettype = _MONERO_Wallet_nettypePtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_useForkRules( + ffi.Pointer 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.Uint8, + ffi.Int64)>>('MONERO_Wallet_useForkRules'); + late final _MONERO_Wallet_useForkRules = _MONERO_Wallet_useForkRulesPtr + .asFunction, int, int)>(); + + ffi.Pointer MONERO_Wallet_integratedAddress( + ffi.Pointer wallet_ptr, + ffi.Pointer payment_id, + ) { + return _MONERO_Wallet_integratedAddress( + wallet_ptr, + payment_id, + ); + } + + late final _MONERO_Wallet_integratedAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_integratedAddress'); + late final _MONERO_Wallet_integratedAddress = + _MONERO_Wallet_integratedAddressPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_secretViewKey( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_secretViewKey( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_secretViewKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_secretViewKey'); + late final _MONERO_Wallet_secretViewKey = _MONERO_Wallet_secretViewKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_publicViewKey( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_publicViewKey( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_publicViewKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_publicViewKey'); + late final _MONERO_Wallet_publicViewKey = _MONERO_Wallet_publicViewKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_secretSpendKey( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_secretSpendKey( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_secretSpendKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_secretSpendKey'); + late final _MONERO_Wallet_secretSpendKey = _MONERO_Wallet_secretSpendKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_publicSpendKey( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_publicSpendKey( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_publicSpendKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_publicSpendKey'); + late final _MONERO_Wallet_publicSpendKey = _MONERO_Wallet_publicSpendKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_publicMultisigSignerKey( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_publicMultisigSignerKey( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_publicMultisigSignerKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_publicMultisigSignerKey'); + late final _MONERO_Wallet_publicMultisigSignerKey = + _MONERO_Wallet_publicMultisigSignerKeyPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void MONERO_Wallet_stop( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_stop( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_stopPtr = + _lookup)>>( + 'MONERO_Wallet_stop'); + late final _MONERO_Wallet_stop = + _MONERO_Wallet_stopPtr.asFunction)>(); + + bool MONERO_Wallet_store( + ffi.Pointer wallet_ptr, + ffi.Pointer path, + ) { + return _MONERO_Wallet_store( + wallet_ptr, + path, + ); + } + + late final _MONERO_Wallet_storePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_store'); + late final _MONERO_Wallet_store = _MONERO_Wallet_storePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_filename( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_filename( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_filenamePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_filename'); + late final _MONERO_Wallet_filename = _MONERO_Wallet_filenamePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_keysFilename( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_keysFilename( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_keysFilenamePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_keysFilename'); + late final _MONERO_Wallet_keysFilename = _MONERO_Wallet_keysFilenamePtr + .asFunction Function(ffi.Pointer)>(); + + bool MONERO_Wallet_init( + ffi.Pointer wallet_ptr, + ffi.Pointer daemon_address, + int upper_transaction_size_limit, + ffi.Pointer daemon_username, + ffi.Pointer daemon_password, + bool use_ssl, + bool lightWallet, + ffi.Pointer 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.Pointer, + ffi.Uint64, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Bool, + ffi.Pointer)>>('MONERO_Wallet_init'); + late final _MONERO_Wallet_init = _MONERO_Wallet_initPtr.asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + bool, + bool, + ffi.Pointer)>(); + + bool MONERO_Wallet_createWatchOnly( + ffi.Pointer wallet_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + ) { + return _MONERO_Wallet_createWatchOnly( + wallet_ptr, + path, + password, + language, + ); + } + + late final _MONERO_Wallet_createWatchOnlyPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_createWatchOnly'); + late final _MONERO_Wallet_createWatchOnly = + _MONERO_Wallet_createWatchOnlyPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + void MONERO_Wallet_setRefreshFromBlockHeight( + ffi.Pointer 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.Uint64)>>('MONERO_Wallet_setRefreshFromBlockHeight'); + late final _MONERO_Wallet_setRefreshFromBlockHeight = + _MONERO_Wallet_setRefreshFromBlockHeightPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + int MONERO_Wallet_getRefreshFromBlockHeight( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getRefreshFromBlockHeight( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getRefreshFromBlockHeightPtr = + _lookup)>>( + 'MONERO_Wallet_getRefreshFromBlockHeight'); + late final _MONERO_Wallet_getRefreshFromBlockHeight = + _MONERO_Wallet_getRefreshFromBlockHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + void MONERO_Wallet_setRecoveringFromSeed( + ffi.Pointer wallet_ptr, + bool recoveringFromSeed, + ) { + return _MONERO_Wallet_setRecoveringFromSeed( + wallet_ptr, + recoveringFromSeed, + ); + } + + late final _MONERO_Wallet_setRecoveringFromSeedPtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'MONERO_Wallet_setRecoveringFromSeed'); + late final _MONERO_Wallet_setRecoveringFromSeed = + _MONERO_Wallet_setRecoveringFromSeedPtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + void MONERO_Wallet_setRecoveringFromDevice( + ffi.Pointer wallet_ptr, + bool recoveringFromDevice, + ) { + return _MONERO_Wallet_setRecoveringFromDevice( + wallet_ptr, + recoveringFromDevice, + ); + } + + late final _MONERO_Wallet_setRecoveringFromDevicePtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'MONERO_Wallet_setRecoveringFromDevice'); + late final _MONERO_Wallet_setRecoveringFromDevice = + _MONERO_Wallet_setRecoveringFromDevicePtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + void MONERO_Wallet_setSubaddressLookahead( + ffi.Pointer 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.Uint32, + ffi.Uint32)>>('MONERO_Wallet_setSubaddressLookahead'); + late final _MONERO_Wallet_setSubaddressLookahead = + _MONERO_Wallet_setSubaddressLookaheadPtr.asFunction< + void Function(ffi.Pointer, int, int)>(); + + bool MONERO_Wallet_connectToDaemon( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_connectToDaemon( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_connectToDaemonPtr = + _lookup)>>( + 'MONERO_Wallet_connectToDaemon'); + late final _MONERO_Wallet_connectToDaemon = _MONERO_Wallet_connectToDaemonPtr + .asFunction)>(); + + int MONERO_Wallet_connected( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_connected( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_connectedPtr = + _lookup)>>( + 'MONERO_Wallet_connected'); + late final _MONERO_Wallet_connected = _MONERO_Wallet_connectedPtr.asFunction< + int Function(ffi.Pointer)>(); + + void MONERO_Wallet_setTrustedDaemon( + ffi.Pointer wallet_ptr, + bool arg, + ) { + return _MONERO_Wallet_setTrustedDaemon( + wallet_ptr, + arg, + ); + } + + late final _MONERO_Wallet_setTrustedDaemonPtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'MONERO_Wallet_setTrustedDaemon'); + late final _MONERO_Wallet_setTrustedDaemon = + _MONERO_Wallet_setTrustedDaemonPtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + bool MONERO_Wallet_trustedDaemon( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_trustedDaemon( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_trustedDaemonPtr = + _lookup)>>( + 'MONERO_Wallet_trustedDaemon'); + late final _MONERO_Wallet_trustedDaemon = _MONERO_Wallet_trustedDaemonPtr + .asFunction)>(); + + bool MONERO_Wallet_setProxy( + ffi.Pointer wallet_ptr, + ffi.Pointer address, + ) { + return _MONERO_Wallet_setProxy( + wallet_ptr, + address, + ); + } + + late final _MONERO_Wallet_setProxyPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setProxy'); + late final _MONERO_Wallet_setProxy = _MONERO_Wallet_setProxyPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + int MONERO_Wallet_balance( + ffi.Pointer 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.Uint32)>>('MONERO_Wallet_balance'); + late final _MONERO_Wallet_balance = _MONERO_Wallet_balancePtr.asFunction< + int Function(ffi.Pointer, int)>(); + + int MONERO_Wallet_unlockedBalance( + ffi.Pointer 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.Uint32)>>('MONERO_Wallet_unlockedBalance'); + late final _MONERO_Wallet_unlockedBalance = _MONERO_Wallet_unlockedBalancePtr + .asFunction, int)>(); + + int MONERO_Wallet_viewOnlyBalance( + ffi.Pointer 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.Uint32)>>('MONERO_Wallet_viewOnlyBalance'); + late final _MONERO_Wallet_viewOnlyBalance = _MONERO_Wallet_viewOnlyBalancePtr + .asFunction, int)>(); + + bool MONERO_Wallet_watchOnly( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_watchOnly( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_watchOnlyPtr = + _lookup)>>( + 'MONERO_Wallet_watchOnly'); + late final _MONERO_Wallet_watchOnly = _MONERO_Wallet_watchOnlyPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_Wallet_isDeterministic( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_isDeterministic( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_isDeterministicPtr = + _lookup)>>( + 'MONERO_Wallet_isDeterministic'); + late final _MONERO_Wallet_isDeterministic = _MONERO_Wallet_isDeterministicPtr + .asFunction)>(); + + int MONERO_Wallet_blockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_blockChainHeight( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_blockChainHeightPtr = + _lookup)>>( + 'MONERO_Wallet_blockChainHeight'); + late final _MONERO_Wallet_blockChainHeight = + _MONERO_Wallet_blockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_approximateBlockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_approximateBlockChainHeight( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_approximateBlockChainHeightPtr = + _lookup)>>( + 'MONERO_Wallet_approximateBlockChainHeight'); + late final _MONERO_Wallet_approximateBlockChainHeight = + _MONERO_Wallet_approximateBlockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_estimateBlockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_estimateBlockChainHeight( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_estimateBlockChainHeightPtr = + _lookup)>>( + 'MONERO_Wallet_estimateBlockChainHeight'); + late final _MONERO_Wallet_estimateBlockChainHeight = + _MONERO_Wallet_estimateBlockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_daemonBlockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_daemonBlockChainHeight( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_daemonBlockChainHeightPtr = + _lookup)>>( + 'MONERO_Wallet_daemonBlockChainHeight'); + late final _MONERO_Wallet_daemonBlockChainHeight = + _MONERO_Wallet_daemonBlockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_daemonBlockChainHeight_cached( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_daemonBlockChainHeight_cached( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_daemonBlockChainHeight_cachedPtr = + _lookup)>>( + 'MONERO_Wallet_daemonBlockChainHeight_cached'); + late final _MONERO_Wallet_daemonBlockChainHeight_cached = + _MONERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction< + int Function(ffi.Pointer)>(); + + void MONERO_Wallet_daemonBlockChainHeight_runThread( + ffi.Pointer wallet_ptr, + int seconds, + ) { + return _MONERO_Wallet_daemonBlockChainHeight_runThread( + wallet_ptr, + seconds, + ); + } + + late final _MONERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'MONERO_Wallet_daemonBlockChainHeight_runThread'); + late final _MONERO_Wallet_daemonBlockChainHeight_runThread = + _MONERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + int MONERO_Wallet_daemonBlockChainTargetHeight( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_daemonBlockChainTargetHeight( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_daemonBlockChainTargetHeightPtr = + _lookup)>>( + 'MONERO_Wallet_daemonBlockChainTargetHeight'); + late final _MONERO_Wallet_daemonBlockChainTargetHeight = + _MONERO_Wallet_daemonBlockChainTargetHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_Wallet_synchronized( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_synchronized( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_synchronizedPtr = + _lookup)>>( + 'MONERO_Wallet_synchronized'); + late final _MONERO_Wallet_synchronized = _MONERO_Wallet_synchronizedPtr + .asFunction)>(); + + ffi.Pointer MONERO_Wallet_displayAmount( + int amount, + ) { + return _MONERO_Wallet_displayAmount( + amount, + ); + } + + late final _MONERO_Wallet_displayAmountPtr = + _lookup Function(ffi.Uint64)>>( + 'MONERO_Wallet_displayAmount'); + late final _MONERO_Wallet_displayAmount = _MONERO_Wallet_displayAmountPtr + .asFunction Function(int)>(); + + int MONERO_Wallet_amountFromString( + ffi.Pointer amount, + ) { + return _MONERO_Wallet_amountFromString( + amount, + ); + } + + late final _MONERO_Wallet_amountFromStringPtr = + _lookup)>>( + 'MONERO_Wallet_amountFromString'); + late final _MONERO_Wallet_amountFromString = + _MONERO_Wallet_amountFromStringPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_amountFromDouble( + double amount, + ) { + return _MONERO_Wallet_amountFromDouble( + amount, + ); + } + + late final _MONERO_Wallet_amountFromDoublePtr = + _lookup>( + 'MONERO_Wallet_amountFromDouble'); + late final _MONERO_Wallet_amountFromDouble = + _MONERO_Wallet_amountFromDoublePtr.asFunction(); + + ffi.Pointer MONERO_Wallet_genPaymentId() { + return _MONERO_Wallet_genPaymentId(); + } + + late final _MONERO_Wallet_genPaymentIdPtr = + _lookup Function()>>( + 'MONERO_Wallet_genPaymentId'); + late final _MONERO_Wallet_genPaymentId = _MONERO_Wallet_genPaymentIdPtr + .asFunction Function()>(); + + bool MONERO_Wallet_paymentIdValid( + ffi.Pointer paiment_id, + ) { + return _MONERO_Wallet_paymentIdValid( + paiment_id, + ); + } + + late final _MONERO_Wallet_paymentIdValidPtr = + _lookup)>>( + 'MONERO_Wallet_paymentIdValid'); + late final _MONERO_Wallet_paymentIdValid = _MONERO_Wallet_paymentIdValidPtr + .asFunction)>(); + + bool MONERO_Wallet_addressValid( + ffi.Pointer str, + int nettype, + ) { + return _MONERO_Wallet_addressValid( + str, + nettype, + ); + } + + late final _MONERO_Wallet_addressValidPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'MONERO_Wallet_addressValid'); + late final _MONERO_Wallet_addressValid = _MONERO_Wallet_addressValidPtr + .asFunction, int)>(); + + bool MONERO_Wallet_keyValid( + ffi.Pointer secret_key_string, + ffi.Pointer 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.Pointer, + ffi.Bool, ffi.Int)>>('MONERO_Wallet_keyValid'); + late final _MONERO_Wallet_keyValid = _MONERO_Wallet_keyValidPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool, int)>(); + + ffi.Pointer MONERO_Wallet_keyValid_error( + ffi.Pointer secret_key_string, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Int)>>('MONERO_Wallet_keyValid_error'); + late final _MONERO_Wallet_keyValid_error = + _MONERO_Wallet_keyValid_errorPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer, bool, int)>(); + + ffi.Pointer MONERO_Wallet_paymentIdFromAddress( + ffi.Pointer strarg, + int nettype, + ) { + return _MONERO_Wallet_paymentIdFromAddress( + strarg, + nettype, + ); + } + + late final _MONERO_Wallet_paymentIdFromAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('MONERO_Wallet_paymentIdFromAddress'); + late final _MONERO_Wallet_paymentIdFromAddress = + _MONERO_Wallet_paymentIdFromAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int MONERO_Wallet_maximumAllowedAmount() { + return _MONERO_Wallet_maximumAllowedAmount(); + } + + late final _MONERO_Wallet_maximumAllowedAmountPtr = + _lookup>( + 'MONERO_Wallet_maximumAllowedAmount'); + late final _MONERO_Wallet_maximumAllowedAmount = + _MONERO_Wallet_maximumAllowedAmountPtr.asFunction(); + + void MONERO_Wallet_init3( + ffi.Pointer wallet_ptr, + ffi.Pointer argv0, + ffi.Pointer default_log_base_name, + ffi.Pointer 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.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>('MONERO_Wallet_init3'); + late final _MONERO_Wallet_init3 = _MONERO_Wallet_init3Ptr.asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer, bool)>(); + + ffi.Pointer MONERO_Wallet_getPolyseed( + ffi.Pointer wallet_ptr, + ffi.Pointer passphrase, + ) { + return _MONERO_Wallet_getPolyseed( + wallet_ptr, + passphrase, + ); + } + + late final _MONERO_Wallet_getPolyseedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_getPolyseed'); + late final _MONERO_Wallet_getPolyseed = + _MONERO_Wallet_getPolyseedPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_createPolyseed( + ffi.Pointer language, + ) { + return _MONERO_Wallet_createPolyseed( + language, + ); + } + + late final _MONERO_Wallet_createPolyseedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_createPolyseed'); + late final _MONERO_Wallet_createPolyseed = _MONERO_Wallet_createPolyseedPtr + .asFunction Function(ffi.Pointer)>(); + + void MONERO_Wallet_startRefresh( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_startRefresh( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_startRefreshPtr = + _lookup)>>( + 'MONERO_Wallet_startRefresh'); + late final _MONERO_Wallet_startRefresh = _MONERO_Wallet_startRefreshPtr + .asFunction)>(); + + void MONERO_Wallet_pauseRefresh( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_pauseRefresh( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_pauseRefreshPtr = + _lookup)>>( + 'MONERO_Wallet_pauseRefresh'); + late final _MONERO_Wallet_pauseRefresh = _MONERO_Wallet_pauseRefreshPtr + .asFunction)>(); + + bool MONERO_Wallet_refresh( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_refresh( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_refreshPtr = + _lookup)>>( + 'MONERO_Wallet_refresh'); + late final _MONERO_Wallet_refresh = _MONERO_Wallet_refreshPtr.asFunction< + bool Function(ffi.Pointer)>(); + + void MONERO_Wallet_refreshAsync( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_refreshAsync( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_refreshAsyncPtr = + _lookup)>>( + 'MONERO_Wallet_refreshAsync'); + late final _MONERO_Wallet_refreshAsync = _MONERO_Wallet_refreshAsyncPtr + .asFunction)>(); + + bool MONERO_Wallet_rescanBlockchain( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_rescanBlockchain( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_rescanBlockchainPtr = + _lookup)>>( + 'MONERO_Wallet_rescanBlockchain'); + late final _MONERO_Wallet_rescanBlockchain = + _MONERO_Wallet_rescanBlockchainPtr.asFunction< + bool Function(ffi.Pointer)>(); + + void MONERO_Wallet_rescanBlockchainAsync( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_rescanBlockchainAsync( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_rescanBlockchainAsyncPtr = + _lookup)>>( + 'MONERO_Wallet_rescanBlockchainAsync'); + late final _MONERO_Wallet_rescanBlockchainAsync = + _MONERO_Wallet_rescanBlockchainAsyncPtr.asFunction< + void Function(ffi.Pointer)>(); + + void MONERO_Wallet_setAutoRefreshInterval( + ffi.Pointer wallet_ptr, + int millis, + ) { + return _MONERO_Wallet_setAutoRefreshInterval( + wallet_ptr, + millis, + ); + } + + late final _MONERO_Wallet_setAutoRefreshIntervalPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'MONERO_Wallet_setAutoRefreshInterval'); + late final _MONERO_Wallet_setAutoRefreshInterval = + _MONERO_Wallet_setAutoRefreshIntervalPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + int MONERO_Wallet_autoRefreshInterval( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_autoRefreshInterval( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_autoRefreshIntervalPtr = + _lookup)>>( + 'MONERO_Wallet_autoRefreshInterval'); + late final _MONERO_Wallet_autoRefreshInterval = + _MONERO_Wallet_autoRefreshIntervalPtr.asFunction< + int Function(ffi.Pointer)>(); + + void MONERO_Wallet_addSubaddressAccount( + ffi.Pointer wallet_ptr, + ffi.Pointer label, + ) { + return _MONERO_Wallet_addSubaddressAccount( + wallet_ptr, + label, + ); + } + + late final _MONERO_Wallet_addSubaddressAccountPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_addSubaddressAccount'); + late final _MONERO_Wallet_addSubaddressAccount = + _MONERO_Wallet_addSubaddressAccountPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + int MONERO_Wallet_numSubaddressAccounts( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_numSubaddressAccounts( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_numSubaddressAccountsPtr = + _lookup)>>( + 'MONERO_Wallet_numSubaddressAccounts'); + late final _MONERO_Wallet_numSubaddressAccounts = + _MONERO_Wallet_numSubaddressAccountsPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_numSubaddresses( + ffi.Pointer 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.Uint32)>>('MONERO_Wallet_numSubaddresses'); + late final _MONERO_Wallet_numSubaddresses = _MONERO_Wallet_numSubaddressesPtr + .asFunction, int)>(); + + void MONERO_Wallet_addSubaddress( + ffi.Pointer wallet_ptr, + int accountIndex, + ffi.Pointer label, + ) { + return _MONERO_Wallet_addSubaddress( + wallet_ptr, + accountIndex, + label, + ); + } + + late final _MONERO_Wallet_addSubaddressPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, + ffi.Pointer)>>('MONERO_Wallet_addSubaddress'); + late final _MONERO_Wallet_addSubaddress = + _MONERO_Wallet_addSubaddressPtr.asFunction< + void Function(ffi.Pointer, int, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getSubaddressLabel( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ) { + return _MONERO_Wallet_getSubaddressLabel( + wallet_ptr, + accountIndex, + addressIndex, + ); + } + + late final _MONERO_Wallet_getSubaddressLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, ffi.Uint32, + ffi.Uint32)>>('MONERO_Wallet_getSubaddressLabel'); + late final _MONERO_Wallet_getSubaddressLabel = + _MONERO_Wallet_getSubaddressLabelPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, int)>(); + + void MONERO_Wallet_setSubaddressLabel( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ffi.Pointer label, + ) { + return _MONERO_Wallet_setSubaddressLabel( + wallet_ptr, + accountIndex, + addressIndex, + label, + ); + } + + late final _MONERO_Wallet_setSubaddressLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, ffi.Uint32, + ffi.Pointer)>>('MONERO_Wallet_setSubaddressLabel'); + late final _MONERO_Wallet_setSubaddressLabel = + _MONERO_Wallet_setSubaddressLabelPtr.asFunction< + void Function( + ffi.Pointer, int, int, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_multisig( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_multisig( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_multisigPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_multisig'); + late final _MONERO_Wallet_multisig = _MONERO_Wallet_multisigPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getMultisigInfo( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getMultisigInfo( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getMultisigInfoPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_getMultisigInfo'); + late final _MONERO_Wallet_getMultisigInfo = _MONERO_Wallet_getMultisigInfoPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_makeMultisig( + ffi.Pointer wallet_ptr, + ffi.Pointer info, + ffi.Pointer info_separator, + int threshold, + ) { + return _MONERO_Wallet_makeMultisig( + wallet_ptr, + info, + info_separator, + threshold, + ); + } + + late final _MONERO_Wallet_makeMultisigPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint32)>>('MONERO_Wallet_makeMultisig'); + late final _MONERO_Wallet_makeMultisig = + _MONERO_Wallet_makeMultisigPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); + + ffi.Pointer MONERO_Wallet_exchangeMultisigKeys( + ffi.Pointer wallet_ptr, + ffi.Pointer info, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>('MONERO_Wallet_exchangeMultisigKeys'); + late final _MONERO_Wallet_exchangeMultisigKeys = + _MONERO_Wallet_exchangeMultisigKeysPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, bool)>(); + + ffi.Pointer MONERO_Wallet_exportMultisigImages( + ffi.Pointer wallet_ptr, + ffi.Pointer separator, + ) { + return _MONERO_Wallet_exportMultisigImages( + wallet_ptr, + separator, + ); + } + + late final _MONERO_Wallet_exportMultisigImagesPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_exportMultisigImages'); + late final _MONERO_Wallet_exportMultisigImages = + _MONERO_Wallet_exportMultisigImagesPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int MONERO_Wallet_importMultisigImages( + ffi.Pointer wallet_ptr, + ffi.Pointer info, + ffi.Pointer 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.Pointer, + ffi.Pointer)>>('MONERO_Wallet_importMultisigImages'); + late final _MONERO_Wallet_importMultisigImages = + _MONERO_Wallet_importMultisigImagesPtr.asFunction< + int Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + int MONERO_Wallet_hasMultisigPartialKeyImages( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_hasMultisigPartialKeyImages( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_hasMultisigPartialKeyImagesPtr = + _lookup)>>( + 'MONERO_Wallet_hasMultisigPartialKeyImages'); + late final _MONERO_Wallet_hasMultisigPartialKeyImages = + _MONERO_Wallet_hasMultisigPartialKeyImagesPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_restoreMultisigTransaction( + ffi.Pointer wallet_ptr, + ffi.Pointer signData, + ) { + return _MONERO_Wallet_restoreMultisigTransaction( + wallet_ptr, + signData, + ); + } + + late final _MONERO_Wallet_restoreMultisigTransactionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'MONERO_Wallet_restoreMultisigTransaction'); + late final _MONERO_Wallet_restoreMultisigTransaction = + _MONERO_Wallet_restoreMultisigTransactionPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_createTransactionMultDest( + ffi.Pointer wallet_ptr, + ffi.Pointer dst_addr_list, + ffi.Pointer dst_addr_list_separator, + ffi.Pointer payment_id, + bool amount_sweep_all, + ffi.Pointer amount_list, + ffi.Pointer amount_list_separator, + int mixin_count, + int pendingTransactionPriority, + int subaddr_account, + ffi.Pointer preferredInputs, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer, + ffi.Pointer, + ffi.Uint32, + ffi.Int, + ffi.Uint32, + ffi.Pointer, + ffi.Pointer)>>( + 'MONERO_Wallet_createTransactionMultDest'); + late final _MONERO_Wallet_createTransactionMultDest = + _MONERO_Wallet_createTransactionMultDestPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_createTransaction( + ffi.Pointer wallet_ptr, + ffi.Pointer dst_addr, + ffi.Pointer payment_id, + int amount, + int mixin_count, + int pendingTransactionPriority, + int subaddr_account, + ffi.Pointer preferredInputs, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint64, + ffi.Uint32, + ffi.Int, + ffi.Uint32, + ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_createTransaction'); + late final _MONERO_Wallet_createTransaction = + _MONERO_Wallet_createTransactionPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + int, + ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_loadUnsignedTx( + ffi.Pointer wallet_ptr, + ffi.Pointer unsigned_filename, + ) { + return _MONERO_Wallet_loadUnsignedTx( + wallet_ptr, + unsigned_filename, + ); + } + + late final _MONERO_Wallet_loadUnsignedTxPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_loadUnsignedTx'); + late final _MONERO_Wallet_loadUnsignedTx = + _MONERO_Wallet_loadUnsignedTxPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_loadUnsignedTxUR( + ffi.Pointer wallet_ptr, + ffi.Pointer input, + ) { + return _MONERO_Wallet_loadUnsignedTxUR( + wallet_ptr, + input, + ); + } + + late final _MONERO_Wallet_loadUnsignedTxURPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_loadUnsignedTxUR'); + late final _MONERO_Wallet_loadUnsignedTxUR = + _MONERO_Wallet_loadUnsignedTxURPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_submitTransaction( + ffi.Pointer wallet_ptr, + ffi.Pointer fileName, + ) { + return _MONERO_Wallet_submitTransaction( + wallet_ptr, + fileName, + ); + } + + late final _MONERO_Wallet_submitTransactionPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_submitTransaction'); + late final _MONERO_Wallet_submitTransaction = + _MONERO_Wallet_submitTransactionPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_submitTransactionUR( + ffi.Pointer wallet_ptr, + ffi.Pointer input, + ) { + return _MONERO_Wallet_submitTransactionUR( + wallet_ptr, + input, + ); + } + + late final _MONERO_Wallet_submitTransactionURPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_submitTransactionUR'); + late final _MONERO_Wallet_submitTransactionUR = + _MONERO_Wallet_submitTransactionURPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_hasUnknownKeyImages( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_hasUnknownKeyImages( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_hasUnknownKeyImagesPtr = + _lookup)>>( + 'MONERO_Wallet_hasUnknownKeyImages'); + late final _MONERO_Wallet_hasUnknownKeyImages = + _MONERO_Wallet_hasUnknownKeyImagesPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_Wallet_exportKeyImages( + ffi.Pointer wallet_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('MONERO_Wallet_exportKeyImages'); + late final _MONERO_Wallet_exportKeyImages = + _MONERO_Wallet_exportKeyImagesPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + ffi.Pointer MONERO_Wallet_exportKeyImagesUR( + ffi.Pointer 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 Function(ffi.Pointer, ffi.Size, + ffi.Bool)>>('MONERO_Wallet_exportKeyImagesUR'); + late final _MONERO_Wallet_exportKeyImagesUR = + _MONERO_Wallet_exportKeyImagesURPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, bool)>(); + + bool MONERO_Wallet_importKeyImages( + ffi.Pointer wallet_ptr, + ffi.Pointer filename, + ) { + return _MONERO_Wallet_importKeyImages( + wallet_ptr, + filename, + ); + } + + late final _MONERO_Wallet_importKeyImagesPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_importKeyImages'); + late final _MONERO_Wallet_importKeyImages = + _MONERO_Wallet_importKeyImagesPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_importKeyImagesUR( + ffi.Pointer wallet_ptr, + ffi.Pointer input, + ) { + return _MONERO_Wallet_importKeyImagesUR( + wallet_ptr, + input, + ); + } + + late final _MONERO_Wallet_importKeyImagesURPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_importKeyImagesUR'); + late final _MONERO_Wallet_importKeyImagesUR = + _MONERO_Wallet_importKeyImagesURPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_exportOutputs( + ffi.Pointer wallet_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('MONERO_Wallet_exportOutputs'); + late final _MONERO_Wallet_exportOutputs = + _MONERO_Wallet_exportOutputsPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + ffi.Pointer MONERO_Wallet_exportOutputsUR( + ffi.Pointer 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 Function(ffi.Pointer, ffi.Size, + ffi.Bool)>>('MONERO_Wallet_exportOutputsUR'); + late final _MONERO_Wallet_exportOutputsUR = + _MONERO_Wallet_exportOutputsURPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, bool)>(); + + bool MONERO_Wallet_importOutputs( + ffi.Pointer wallet_ptr, + ffi.Pointer filename, + ) { + return _MONERO_Wallet_importOutputs( + wallet_ptr, + filename, + ); + } + + late final _MONERO_Wallet_importOutputsPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_importOutputs'); + late final _MONERO_Wallet_importOutputs = + _MONERO_Wallet_importOutputsPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_importOutputsUR( + ffi.Pointer wallet_ptr, + ffi.Pointer input, + ) { + return _MONERO_Wallet_importOutputsUR( + wallet_ptr, + input, + ); + } + + late final _MONERO_Wallet_importOutputsURPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_importOutputsUR'); + late final _MONERO_Wallet_importOutputsUR = + _MONERO_Wallet_importOutputsURPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_setupBackgroundSync( + ffi.Pointer wallet_ptr, + int background_sync_type, + ffi.Pointer wallet_password, + ffi.Pointer 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.Int, + ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setupBackgroundSync'); + late final _MONERO_Wallet_setupBackgroundSync = + _MONERO_Wallet_setupBackgroundSyncPtr.asFunction< + bool Function(ffi.Pointer, int, ffi.Pointer, + ffi.Pointer)>(); + + int MONERO_Wallet_getBackgroundSyncType( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getBackgroundSyncType( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getBackgroundSyncTypePtr = + _lookup)>>( + 'MONERO_Wallet_getBackgroundSyncType'); + late final _MONERO_Wallet_getBackgroundSyncType = + _MONERO_Wallet_getBackgroundSyncTypePtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_Wallet_startBackgroundSync( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_startBackgroundSync( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_startBackgroundSyncPtr = + _lookup)>>( + 'MONERO_Wallet_startBackgroundSync'); + late final _MONERO_Wallet_startBackgroundSync = + _MONERO_Wallet_startBackgroundSyncPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_Wallet_stopBackgroundSync( + ffi.Pointer wallet_ptr, + ffi.Pointer wallet_password, + ) { + return _MONERO_Wallet_stopBackgroundSync( + wallet_ptr, + wallet_password, + ); + } + + late final _MONERO_Wallet_stopBackgroundSyncPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_stopBackgroundSync'); + late final _MONERO_Wallet_stopBackgroundSync = + _MONERO_Wallet_stopBackgroundSyncPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_isBackgroundSyncing( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_isBackgroundSyncing( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_isBackgroundSyncingPtr = + _lookup)>>( + 'MONERO_Wallet_isBackgroundSyncing'); + late final _MONERO_Wallet_isBackgroundSyncing = + _MONERO_Wallet_isBackgroundSyncingPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_Wallet_isBackgroundWallet( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_isBackgroundWallet( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_isBackgroundWalletPtr = + _lookup)>>( + 'MONERO_Wallet_isBackgroundWallet'); + late final _MONERO_Wallet_isBackgroundWallet = + _MONERO_Wallet_isBackgroundWalletPtr.asFunction< + bool Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_history( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_history( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_historyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_history'); + late final _MONERO_Wallet_history = _MONERO_Wallet_historyPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_addressBook( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_addressBook( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_addressBookPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_addressBook'); + late final _MONERO_Wallet_addressBook = _MONERO_Wallet_addressBookPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_coins( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_coins( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_coinsPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_coins'); + late final _MONERO_Wallet_coins = _MONERO_Wallet_coinsPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_subaddress( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_subaddress( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_subaddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_subaddress'); + late final _MONERO_Wallet_subaddress = _MONERO_Wallet_subaddressPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_subaddressAccount( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_subaddressAccount( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_subaddressAccountPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_subaddressAccount'); + late final _MONERO_Wallet_subaddressAccount = + _MONERO_Wallet_subaddressAccountPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_Wallet_defaultMixin( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_defaultMixin( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_defaultMixinPtr = + _lookup)>>( + 'MONERO_Wallet_defaultMixin'); + late final _MONERO_Wallet_defaultMixin = _MONERO_Wallet_defaultMixinPtr + .asFunction)>(); + + void MONERO_Wallet_setDefaultMixin( + ffi.Pointer 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.Uint32)>>('MONERO_Wallet_setDefaultMixin'); + late final _MONERO_Wallet_setDefaultMixin = _MONERO_Wallet_setDefaultMixinPtr + .asFunction, int)>(); + + bool MONERO_Wallet_setCacheAttribute( + ffi.Pointer wallet_ptr, + ffi.Pointer key, + ffi.Pointer val, + ) { + return _MONERO_Wallet_setCacheAttribute( + wallet_ptr, + key, + val, + ); + } + + late final _MONERO_Wallet_setCacheAttributePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setCacheAttribute'); + late final _MONERO_Wallet_setCacheAttribute = + _MONERO_Wallet_setCacheAttributePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getCacheAttribute( + ffi.Pointer wallet_ptr, + ffi.Pointer key, + ) { + return _MONERO_Wallet_getCacheAttribute( + wallet_ptr, + key, + ); + } + + late final _MONERO_Wallet_getCacheAttributePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_getCacheAttribute'); + late final _MONERO_Wallet_getCacheAttribute = + _MONERO_Wallet_getCacheAttributePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_setUserNote( + ffi.Pointer wallet_ptr, + ffi.Pointer txid, + ffi.Pointer note, + ) { + return _MONERO_Wallet_setUserNote( + wallet_ptr, + txid, + note, + ); + } + + late final _MONERO_Wallet_setUserNotePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_setUserNote'); + late final _MONERO_Wallet_setUserNote = + _MONERO_Wallet_setUserNotePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getUserNote( + ffi.Pointer wallet_ptr, + ffi.Pointer txid, + ) { + return _MONERO_Wallet_getUserNote( + wallet_ptr, + txid, + ); + } + + late final _MONERO_Wallet_getUserNotePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_getUserNote'); + late final _MONERO_Wallet_getUserNote = + _MONERO_Wallet_getUserNotePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getTxKey( + ffi.Pointer wallet_ptr, + ffi.Pointer txid, + ) { + return _MONERO_Wallet_getTxKey( + wallet_ptr, + txid, + ); + } + + late final _MONERO_Wallet_getTxKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_getTxKey'); + late final _MONERO_Wallet_getTxKey = _MONERO_Wallet_getTxKeyPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_signMessage( + ffi.Pointer wallet_ptr, + ffi.Pointer message, + ffi.Pointer address, + ) { + return _MONERO_Wallet_signMessage( + wallet_ptr, + message, + address, + ); + } + + late final _MONERO_Wallet_signMessagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_signMessage'); + late final _MONERO_Wallet_signMessage = + _MONERO_Wallet_signMessagePtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_verifySignedMessage( + ffi.Pointer wallet_ptr, + ffi.Pointer message, + ffi.Pointer address, + ffi.Pointer signature, + ) { + return _MONERO_Wallet_verifySignedMessage( + wallet_ptr, + message, + address, + signature, + ); + } + + late final _MONERO_Wallet_verifySignedMessagePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('MONERO_Wallet_verifySignedMessage'); + late final _MONERO_Wallet_verifySignedMessage = + _MONERO_Wallet_verifySignedMessagePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_Wallet_rescanSpent( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_rescanSpent( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_rescanSpentPtr = + _lookup)>>( + 'MONERO_Wallet_rescanSpent'); + late final _MONERO_Wallet_rescanSpent = _MONERO_Wallet_rescanSpentPtr + .asFunction)>(); + + void MONERO_Wallet_setOffline( + ffi.Pointer wallet_ptr, + bool offline, + ) { + return _MONERO_Wallet_setOffline( + wallet_ptr, + offline, + ); + } + + late final _MONERO_Wallet_setOfflinePtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'MONERO_Wallet_setOffline'); + late final _MONERO_Wallet_setOffline = _MONERO_Wallet_setOfflinePtr + .asFunction, bool)>(); + + bool MONERO_Wallet_isOffline( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_isOffline( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_isOfflinePtr = + _lookup)>>( + 'MONERO_Wallet_isOffline'); + late final _MONERO_Wallet_isOffline = _MONERO_Wallet_isOfflinePtr.asFunction< + bool Function(ffi.Pointer)>(); + + void MONERO_Wallet_segregatePreForkOutputs( + ffi.Pointer wallet_ptr, + bool segregate, + ) { + return _MONERO_Wallet_segregatePreForkOutputs( + wallet_ptr, + segregate, + ); + } + + late final _MONERO_Wallet_segregatePreForkOutputsPtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'MONERO_Wallet_segregatePreForkOutputs'); + late final _MONERO_Wallet_segregatePreForkOutputs = + _MONERO_Wallet_segregatePreForkOutputsPtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + void MONERO_Wallet_segregationHeight( + ffi.Pointer 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.Uint64)>>('MONERO_Wallet_segregationHeight'); + late final _MONERO_Wallet_segregationHeight = + _MONERO_Wallet_segregationHeightPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + void MONERO_Wallet_keyReuseMitigation2( + ffi.Pointer wallet_ptr, + bool mitigation, + ) { + return _MONERO_Wallet_keyReuseMitigation2( + wallet_ptr, + mitigation, + ); + } + + late final _MONERO_Wallet_keyReuseMitigation2Ptr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'MONERO_Wallet_keyReuseMitigation2'); + late final _MONERO_Wallet_keyReuseMitigation2 = + _MONERO_Wallet_keyReuseMitigation2Ptr.asFunction< + void Function(ffi.Pointer, bool)>(); + + bool MONERO_Wallet_lockKeysFile( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_lockKeysFile( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_lockKeysFilePtr = + _lookup)>>( + 'MONERO_Wallet_lockKeysFile'); + late final _MONERO_Wallet_lockKeysFile = _MONERO_Wallet_lockKeysFilePtr + .asFunction)>(); + + bool MONERO_Wallet_unlockKeysFile( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_unlockKeysFile( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_unlockKeysFilePtr = + _lookup)>>( + 'MONERO_Wallet_unlockKeysFile'); + late final _MONERO_Wallet_unlockKeysFile = _MONERO_Wallet_unlockKeysFilePtr + .asFunction)>(); + + bool MONERO_Wallet_isKeysFileLocked( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_isKeysFileLocked( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_isKeysFileLockedPtr = + _lookup)>>( + 'MONERO_Wallet_isKeysFileLocked'); + late final _MONERO_Wallet_isKeysFileLocked = + _MONERO_Wallet_isKeysFileLockedPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int MONERO_Wallet_getDeviceType( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getDeviceType( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getDeviceTypePtr = + _lookup)>>( + 'MONERO_Wallet_getDeviceType'); + late final _MONERO_Wallet_getDeviceType = _MONERO_Wallet_getDeviceTypePtr + .asFunction)>(); + + int MONERO_Wallet_coldKeyImageSync( + ffi.Pointer 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.Uint64, + ffi.Uint64)>>('MONERO_Wallet_coldKeyImageSync'); + late final _MONERO_Wallet_coldKeyImageSync = + _MONERO_Wallet_coldKeyImageSyncPtr.asFunction< + int Function(ffi.Pointer, int, int)>(); + + ffi.Pointer MONERO_Wallet_deviceShowAddress( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ) { + return _MONERO_Wallet_deviceShowAddress( + wallet_ptr, + accountIndex, + addressIndex, + ); + } + + late final _MONERO_Wallet_deviceShowAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, ffi.Uint32, + ffi.Uint32)>>('MONERO_Wallet_deviceShowAddress'); + late final _MONERO_Wallet_deviceShowAddress = + _MONERO_Wallet_deviceShowAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, int)>(); + + bool MONERO_Wallet_reconnectDevice( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_reconnectDevice( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_reconnectDevicePtr = + _lookup)>>( + 'MONERO_Wallet_reconnectDevice'); + late final _MONERO_Wallet_reconnectDevice = _MONERO_Wallet_reconnectDevicePtr + .asFunction)>(); + + int MONERO_Wallet_getBytesReceived( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getBytesReceived( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getBytesReceivedPtr = + _lookup)>>( + 'MONERO_Wallet_getBytesReceived'); + late final _MONERO_Wallet_getBytesReceived = + _MONERO_Wallet_getBytesReceivedPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_Wallet_getBytesSent( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getBytesSent( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getBytesSentPtr = + _lookup)>>( + 'MONERO_Wallet_getBytesSent'); + late final _MONERO_Wallet_getBytesSent = _MONERO_Wallet_getBytesSentPtr + .asFunction)>(); + + bool MONERO_Wallet_getStateIsConnected( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getStateIsConnected( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getStateIsConnectedPtr = + _lookup)>>( + 'MONERO_Wallet_getStateIsConnected'); + late final _MONERO_Wallet_getStateIsConnected = + _MONERO_Wallet_getStateIsConnectedPtr.asFunction< + bool Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getSendToDevice( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getSendToDevice( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getSendToDevicePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_getSendToDevice'); + late final _MONERO_Wallet_getSendToDevice = + _MONERO_Wallet_getSendToDevicePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_Wallet_getSendToDeviceLength( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getSendToDeviceLength( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getSendToDeviceLengthPtr = + _lookup)>>( + 'MONERO_Wallet_getSendToDeviceLength'); + late final _MONERO_Wallet_getSendToDeviceLength = + _MONERO_Wallet_getSendToDeviceLengthPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer MONERO_Wallet_getReceivedFromDevice( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getReceivedFromDevice( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getReceivedFromDevicePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_Wallet_getReceivedFromDevice'); + late final _MONERO_Wallet_getReceivedFromDevice = + _MONERO_Wallet_getReceivedFromDevicePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int MONERO_Wallet_getReceivedFromDeviceLength( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getReceivedFromDeviceLength( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getReceivedFromDeviceLengthPtr = + _lookup)>>( + 'MONERO_Wallet_getReceivedFromDeviceLength'); + late final _MONERO_Wallet_getReceivedFromDeviceLength = + _MONERO_Wallet_getReceivedFromDeviceLengthPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_Wallet_getWaitsForDeviceSend( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getWaitsForDeviceSend( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getWaitsForDeviceSendPtr = + _lookup)>>( + 'MONERO_Wallet_getWaitsForDeviceSend'); + late final _MONERO_Wallet_getWaitsForDeviceSend = + _MONERO_Wallet_getWaitsForDeviceSendPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_Wallet_getWaitsForDeviceReceive( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_Wallet_getWaitsForDeviceReceive( + wallet_ptr, + ); + } + + late final _MONERO_Wallet_getWaitsForDeviceReceivePtr = + _lookup)>>( + 'MONERO_Wallet_getWaitsForDeviceReceive'); + late final _MONERO_Wallet_getWaitsForDeviceReceive = + _MONERO_Wallet_getWaitsForDeviceReceivePtr.asFunction< + bool Function(ffi.Pointer)>(); + + void MONERO_Wallet_setDeviceReceivedData( + ffi.Pointer wallet_ptr, + ffi.Pointer 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.Pointer, + ffi.Size)>>('MONERO_Wallet_setDeviceReceivedData'); + late final _MONERO_Wallet_setDeviceReceivedData = + _MONERO_Wallet_setDeviceReceivedDataPtr.asFunction< + void Function( + ffi.Pointer, ffi.Pointer, int)>(); + + void MONERO_Wallet_setDeviceSendData( + ffi.Pointer wallet_ptr, + ffi.Pointer 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.Pointer, + ffi.Size)>>('MONERO_Wallet_setDeviceSendData'); + late final _MONERO_Wallet_setDeviceSendData = + _MONERO_Wallet_setDeviceSendDataPtr.asFunction< + void Function( + ffi.Pointer, ffi.Pointer, int)>(); + + ffi.Pointer MONERO_WalletManager_createWallet( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int networkType, + ) { + return _MONERO_WalletManager_createWallet( + wm_ptr, + path, + password, + language, + networkType, + ); + } + + late final _MONERO_WalletManager_createWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int)>>('MONERO_WalletManager_createWallet'); + late final _MONERO_WalletManager_createWallet = + _MONERO_WalletManager_createWalletPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + + ffi.Pointer MONERO_WalletManager_openWallet( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + int networkType, + ) { + return _MONERO_WalletManager_openWallet( + wm_ptr, + path, + password, + networkType, + ); + } + + late final _MONERO_WalletManager_openWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int)>>('MONERO_WalletManager_openWallet'); + late final _MONERO_WalletManager_openWallet = + _MONERO_WalletManager_openWalletPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); + + ffi.Pointer MONERO_WalletManager_recoveryWallet( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer mnemonic, + int networkType, + int restoreHeight, + int kdfRounds, + ffi.Pointer seedOffset, + ) { + return _MONERO_WalletManager_recoveryWallet( + wm_ptr, + path, + password, + mnemonic, + networkType, + restoreHeight, + kdfRounds, + seedOffset, + ); + } + + late final _MONERO_WalletManager_recoveryWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Uint64, + ffi.Uint64, + ffi.Pointer)>>('MONERO_WalletManager_recoveryWallet'); + late final _MONERO_WalletManager_recoveryWallet = + _MONERO_WalletManager_recoveryWalletPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + ffi.Pointer MONERO_WalletManager_createWalletFromKeys( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int nettype, + int restoreHeight, + ffi.Pointer addressString, + ffi.Pointer viewKeyString, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Uint64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint64)>>('MONERO_WalletManager_createWalletFromKeys'); + late final _MONERO_WalletManager_createWalletFromKeys = + _MONERO_WalletManager_createWalletFromKeysPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + + ffi.Pointer + MONERO_WalletManager_createDeterministicWalletFromSpendKey( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int nettype, + int restoreHeight, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Uint64, + ffi.Pointer, + ffi.Uint64)>>( + 'MONERO_WalletManager_createDeterministicWalletFromSpendKey'); + late final _MONERO_WalletManager_createDeterministicWalletFromSpendKey = + _MONERO_WalletManager_createDeterministicWalletFromSpendKeyPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer, + int)>(); + + ffi.Pointer MONERO_WalletManager_createWalletFromDevice( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + int nettype, + ffi.Pointer deviceName, + int restoreHeight, + ffi.Pointer subaddressLookahead, + ffi.Pointer viewKeyString, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Pointer, + ffi.Uint64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint64)>>('MONERO_WalletManager_createWalletFromDevice'); + late final _MONERO_WalletManager_createWalletFromDevice = + _MONERO_WalletManager_createWalletFromDevicePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + + ffi.Pointer MONERO_WalletManager_createWalletFromPolyseed( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + int nettype, + ffi.Pointer mnemonic, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Uint64, + ffi.Uint64)>>('MONERO_WalletManager_createWalletFromPolyseed'); + late final _MONERO_WalletManager_createWalletFromPolyseed = + _MONERO_WalletManager_createWalletFromPolyseedPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + bool, + int, + int)>(); + + bool MONERO_WalletManager_closeWallet( + ffi.Pointer wm_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('MONERO_WalletManager_closeWallet'); + late final _MONERO_WalletManager_closeWallet = + _MONERO_WalletManager_closeWalletPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + bool MONERO_WalletManager_walletExists( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ) { + return _MONERO_WalletManager_walletExists( + wm_ptr, + path, + ); + } + + late final _MONERO_WalletManager_walletExistsPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_WalletManager_walletExists'); + late final _MONERO_WalletManager_walletExists = + _MONERO_WalletManager_walletExistsPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool MONERO_WalletManager_verifyWalletPassword( + ffi.Pointer wm_ptr, + ffi.Pointer keys_file_name, + ffi.Pointer 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.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Uint64)>>('MONERO_WalletManager_verifyWalletPassword'); + late final _MONERO_WalletManager_verifyWalletPassword = + _MONERO_WalletManager_verifyWalletPasswordPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, bool, int)>(); + + bool MONERO_WalletManager_queryWalletDevice( + int device_type, + ffi.Pointer keys_file_name, + ffi.Pointer 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.Pointer, + ffi.Uint64)>>('MONERO_WalletManager_queryWalletDevice'); + late final _MONERO_WalletManager_queryWalletDevice = + _MONERO_WalletManager_queryWalletDevicePtr.asFunction< + bool Function( + int, ffi.Pointer, ffi.Pointer, int)>(); + + ffi.Pointer MONERO_WalletManager_findWallets( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer separator, + ) { + return _MONERO_WalletManager_findWallets( + wm_ptr, + path, + separator, + ); + } + + late final _MONERO_WalletManager_findWalletsPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('MONERO_WalletManager_findWallets'); + late final _MONERO_WalletManager_findWallets = + _MONERO_WalletManager_findWalletsPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_WalletManager_errorString( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_errorString( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_WalletManager_errorString'); + late final _MONERO_WalletManager_errorString = + _MONERO_WalletManager_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void MONERO_WalletManager_setDaemonAddress( + ffi.Pointer wm_ptr, + ffi.Pointer address, + ) { + return _MONERO_WalletManager_setDaemonAddress( + wm_ptr, + address, + ); + } + + late final _MONERO_WalletManager_setDaemonAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_WalletManager_setDaemonAddress'); + late final _MONERO_WalletManager_setDaemonAddress = + _MONERO_WalletManager_setDaemonAddressPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + int MONERO_WalletManager_blockchainHeight( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_blockchainHeight( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_blockchainHeightPtr = + _lookup)>>( + 'MONERO_WalletManager_blockchainHeight'); + late final _MONERO_WalletManager_blockchainHeight = + _MONERO_WalletManager_blockchainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_WalletManager_blockchainTargetHeight( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_blockchainTargetHeight( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_blockchainTargetHeightPtr = + _lookup)>>( + 'MONERO_WalletManager_blockchainTargetHeight'); + late final _MONERO_WalletManager_blockchainTargetHeight = + _MONERO_WalletManager_blockchainTargetHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int MONERO_WalletManager_networkDifficulty( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_networkDifficulty( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_networkDifficultyPtr = + _lookup)>>( + 'MONERO_WalletManager_networkDifficulty'); + late final _MONERO_WalletManager_networkDifficulty = + _MONERO_WalletManager_networkDifficultyPtr.asFunction< + int Function(ffi.Pointer)>(); + + double MONERO_WalletManager_miningHashRate( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_miningHashRate( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_miningHashRatePtr = + _lookup)>>( + 'MONERO_WalletManager_miningHashRate'); + late final _MONERO_WalletManager_miningHashRate = + _MONERO_WalletManager_miningHashRatePtr.asFunction< + double Function(ffi.Pointer)>(); + + int MONERO_WalletManager_blockTarget( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_blockTarget( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_blockTargetPtr = + _lookup)>>( + 'MONERO_WalletManager_blockTarget'); + late final _MONERO_WalletManager_blockTarget = + _MONERO_WalletManager_blockTargetPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool MONERO_WalletManager_isMining( + ffi.Pointer wm_ptr, + ) { + return _MONERO_WalletManager_isMining( + wm_ptr, + ); + } + + late final _MONERO_WalletManager_isMiningPtr = + _lookup)>>( + 'MONERO_WalletManager_isMining'); + late final _MONERO_WalletManager_isMining = _MONERO_WalletManager_isMiningPtr + .asFunction)>(); + + bool MONERO_WalletManager_startMining( + ffi.Pointer wm_ptr, + ffi.Pointer 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.Pointer, + ffi.Uint32, + ffi.Bool, + ffi.Bool)>>('MONERO_WalletManager_startMining'); + late final _MONERO_WalletManager_startMining = + _MONERO_WalletManager_startMiningPtr.asFunction< + bool Function( + ffi.Pointer, ffi.Pointer, int, bool, bool)>(); + + bool MONERO_WalletManager_stopMining( + ffi.Pointer wm_ptr, + ffi.Pointer address, + ) { + return _MONERO_WalletManager_stopMining( + wm_ptr, + address, + ); + } + + late final _MONERO_WalletManager_stopMiningPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_WalletManager_stopMining'); + late final _MONERO_WalletManager_stopMining = + _MONERO_WalletManager_stopMiningPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_WalletManager_resolveOpenAlias( + ffi.Pointer wm_ptr, + ffi.Pointer address, + bool dnssec_valid, + ) { + return _MONERO_WalletManager_resolveOpenAlias( + wm_ptr, + address, + dnssec_valid, + ); + } + + late final _MONERO_WalletManager_resolveOpenAliasPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>('MONERO_WalletManager_resolveOpenAlias'); + late final _MONERO_WalletManager_resolveOpenAlias = + _MONERO_WalletManager_resolveOpenAliasPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer, bool)>(); + + bool MONERO_WalletManager_setProxy( + ffi.Pointer wm_ptr, + ffi.Pointer address, + ) { + return _MONERO_WalletManager_setProxy( + wm_ptr, + address, + ); + } + + late final _MONERO_WalletManager_setProxyPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('MONERO_WalletManager_setProxy'); + late final _MONERO_WalletManager_setProxy = + _MONERO_WalletManager_setProxyPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer MONERO_WalletManagerFactory_getWalletManager() { + return _MONERO_WalletManagerFactory_getWalletManager(); + } + + late final _MONERO_WalletManagerFactory_getWalletManagerPtr = + _lookup Function()>>( + 'MONERO_WalletManagerFactory_getWalletManager'); + late final _MONERO_WalletManagerFactory_getWalletManager = + _MONERO_WalletManagerFactory_getWalletManagerPtr.asFunction< + ffi.Pointer Function()>(); + + void MONERO_WalletManagerFactory_setLogLevel( + int level, + ) { + return _MONERO_WalletManagerFactory_setLogLevel( + level, + ); + } + + late final _MONERO_WalletManagerFactory_setLogLevelPtr = + _lookup>( + 'MONERO_WalletManagerFactory_setLogLevel'); + late final _MONERO_WalletManagerFactory_setLogLevel = + _MONERO_WalletManagerFactory_setLogLevelPtr.asFunction< + void Function(int)>(); + + void MONERO_WalletManagerFactory_setLogCategories( + ffi.Pointer categories, + ) { + return _MONERO_WalletManagerFactory_setLogCategories( + categories, + ); + } + + late final _MONERO_WalletManagerFactory_setLogCategoriesPtr = + _lookup)>>( + 'MONERO_WalletManagerFactory_setLogCategories'); + late final _MONERO_WalletManagerFactory_setLogCategories = + _MONERO_WalletManagerFactory_setLogCategoriesPtr.asFunction< + void Function(ffi.Pointer)>(); + + void MONERO_DEBUG_test0() { + return _MONERO_DEBUG_test0(); + } + + late final _MONERO_DEBUG_test0Ptr = + _lookup>('MONERO_DEBUG_test0'); + late final _MONERO_DEBUG_test0 = + _MONERO_DEBUG_test0Ptr.asFunction(); + + bool MONERO_DEBUG_test1( + bool x, + ) { + return _MONERO_DEBUG_test1( + x, + ); + } + + late final _MONERO_DEBUG_test1Ptr = + _lookup>( + 'MONERO_DEBUG_test1'); + late final _MONERO_DEBUG_test1 = + _MONERO_DEBUG_test1Ptr.asFunction(); + + int MONERO_DEBUG_test2( + int x, + ) { + return _MONERO_DEBUG_test2( + x, + ); + } + + late final _MONERO_DEBUG_test2Ptr = + _lookup>( + 'MONERO_DEBUG_test2'); + late final _MONERO_DEBUG_test2 = + _MONERO_DEBUG_test2Ptr.asFunction(); + + int MONERO_DEBUG_test3( + int x, + ) { + return _MONERO_DEBUG_test3( + x, + ); + } + + late final _MONERO_DEBUG_test3Ptr = + _lookup>( + 'MONERO_DEBUG_test3'); + late final _MONERO_DEBUG_test3 = + _MONERO_DEBUG_test3Ptr.asFunction(); + + ffi.Pointer MONERO_DEBUG_test4( + int x, + ) { + return _MONERO_DEBUG_test4( + x, + ); + } + + late final _MONERO_DEBUG_test4Ptr = + _lookup Function(ffi.Uint64)>>( + 'MONERO_DEBUG_test4'); + late final _MONERO_DEBUG_test4 = + _MONERO_DEBUG_test4Ptr.asFunction Function(int)>(); + + ffi.Pointer MONERO_DEBUG_test5() { + return _MONERO_DEBUG_test5(); + } + + late final _MONERO_DEBUG_test5Ptr = + _lookup Function()>>( + 'MONERO_DEBUG_test5'); + late final _MONERO_DEBUG_test5 = + _MONERO_DEBUG_test5Ptr.asFunction Function()>(); + + ffi.Pointer MONERO_DEBUG_test5_std() { + return _MONERO_DEBUG_test5_std(); + } + + late final _MONERO_DEBUG_test5_stdPtr = + _lookup Function()>>( + 'MONERO_DEBUG_test5_std'); + late final _MONERO_DEBUG_test5_std = + _MONERO_DEBUG_test5_stdPtr.asFunction Function()>(); + + bool MONERO_DEBUG_isPointerNull( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_DEBUG_isPointerNull( + wallet_ptr, + ); + } + + late final _MONERO_DEBUG_isPointerNullPtr = + _lookup)>>( + 'MONERO_DEBUG_isPointerNull'); + late final _MONERO_DEBUG_isPointerNull = _MONERO_DEBUG_isPointerNullPtr + .asFunction)>(); + + ffi.Pointer MONERO_cw_getWalletListener( + ffi.Pointer wallet_ptr, + ) { + return _MONERO_cw_getWalletListener( + wallet_ptr, + ); + } + + late final _MONERO_cw_getWalletListenerPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('MONERO_cw_getWalletListener'); + late final _MONERO_cw_getWalletListener = _MONERO_cw_getWalletListenerPtr + .asFunction Function(ffi.Pointer)>(); + + void MONERO_cw_WalletListener_resetNeedToRefresh( + ffi.Pointer cw_walletListener_ptr, + ) { + return _MONERO_cw_WalletListener_resetNeedToRefresh( + cw_walletListener_ptr, + ); + } + + late final _MONERO_cw_WalletListener_resetNeedToRefreshPtr = + _lookup)>>( + 'MONERO_cw_WalletListener_resetNeedToRefresh'); + late final _MONERO_cw_WalletListener_resetNeedToRefresh = + _MONERO_cw_WalletListener_resetNeedToRefreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + bool MONERO_cw_WalletListener_isNeedToRefresh( + ffi.Pointer cw_walletListener_ptr, + ) { + return _MONERO_cw_WalletListener_isNeedToRefresh( + cw_walletListener_ptr, + ); + } + + late final _MONERO_cw_WalletListener_isNeedToRefreshPtr = + _lookup)>>( + 'MONERO_cw_WalletListener_isNeedToRefresh'); + late final _MONERO_cw_WalletListener_isNeedToRefresh = + _MONERO_cw_WalletListener_isNeedToRefreshPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool MONERO_cw_WalletListener_isNewTransactionExist( + ffi.Pointer cw_walletListener_ptr, + ) { + return _MONERO_cw_WalletListener_isNewTransactionExist( + cw_walletListener_ptr, + ); + } + + late final _MONERO_cw_WalletListener_isNewTransactionExistPtr = + _lookup)>>( + 'MONERO_cw_WalletListener_isNewTransactionExist'); + late final _MONERO_cw_WalletListener_isNewTransactionExist = + _MONERO_cw_WalletListener_isNewTransactionExistPtr.asFunction< + bool Function(ffi.Pointer)>(); + + void MONERO_cw_WalletListener_resetIsNewTransactionExist( + ffi.Pointer cw_walletListener_ptr, + ) { + return _MONERO_cw_WalletListener_resetIsNewTransactionExist( + cw_walletListener_ptr, + ); + } + + late final _MONERO_cw_WalletListener_resetIsNewTransactionExistPtr = + _lookup)>>( + 'MONERO_cw_WalletListener_resetIsNewTransactionExist'); + late final _MONERO_cw_WalletListener_resetIsNewTransactionExist = + _MONERO_cw_WalletListener_resetIsNewTransactionExistPtr.asFunction< + void Function(ffi.Pointer)>(); + + int MONERO_cw_WalletListener_height( + ffi.Pointer cw_walletListener_ptr, + ) { + return _MONERO_cw_WalletListener_height( + cw_walletListener_ptr, + ); + } + + late final _MONERO_cw_WalletListener_heightPtr = + _lookup)>>( + 'MONERO_cw_WalletListener_height'); + late final _MONERO_cw_WalletListener_height = + _MONERO_cw_WalletListener_heightPtr.asFunction< + int Function(ffi.Pointer)>(); + + void MONERO_free( + ffi.Pointer ptr, + ) { + return _MONERO_free( + ptr, + ); + } + + late final _MONERO_freePtr = + _lookup)>>( + 'MONERO_free'); + late final _MONERO_free = + _MONERO_freePtr.asFunction)>(); +} + +// intentionally left here \ No newline at end of file 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 00000000..527ab171 --- /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 Function(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 Function(String symbolName) + lookup) + : _lookup = lookup; + + int WOWNERO_PendingTransaction_status( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_status( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_statusPtr = + _lookup)>>( + 'WOWNERO_PendingTransaction_status'); + late final _WOWNERO_PendingTransaction_status = + _WOWNERO_PendingTransaction_statusPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_errorString( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_errorString( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_PendingTransaction_errorString'); + late final _WOWNERO_PendingTransaction_errorString = + _WOWNERO_PendingTransaction_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + bool WOWNERO_PendingTransaction_commit( + ffi.Pointer pendingTx_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('WOWNERO_PendingTransaction_commit'); + late final _WOWNERO_PendingTransaction_commit = + _WOWNERO_PendingTransaction_commitPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + int WOWNERO_PendingTransaction_amount( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_amount( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_amountPtr = + _lookup)>>( + 'WOWNERO_PendingTransaction_amount'); + late final _WOWNERO_PendingTransaction_amount = + _WOWNERO_PendingTransaction_amountPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_PendingTransaction_dust( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_dust( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_dustPtr = + _lookup)>>( + 'WOWNERO_PendingTransaction_dust'); + late final _WOWNERO_PendingTransaction_dust = + _WOWNERO_PendingTransaction_dustPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_PendingTransaction_fee( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_fee( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_feePtr = + _lookup)>>( + 'WOWNERO_PendingTransaction_fee'); + late final _WOWNERO_PendingTransaction_fee = + _WOWNERO_PendingTransaction_feePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_txid( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_PendingTransaction_txid( + pendingTx_ptr, + separator, + ); + } + + late final _WOWNERO_PendingTransaction_txidPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_PendingTransaction_txid'); + late final _WOWNERO_PendingTransaction_txid = + _WOWNERO_PendingTransaction_txidPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_PendingTransaction_txCount( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_txCount( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_txCountPtr = + _lookup)>>( + 'WOWNERO_PendingTransaction_txCount'); + late final _WOWNERO_PendingTransaction_txCount = + _WOWNERO_PendingTransaction_txCountPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_subaddrAccount( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_PendingTransaction_subaddrAccount( + pendingTx_ptr, + separator, + ); + } + + late final _WOWNERO_PendingTransaction_subaddrAccountPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'WOWNERO_PendingTransaction_subaddrAccount'); + late final _WOWNERO_PendingTransaction_subaddrAccount = + _WOWNERO_PendingTransaction_subaddrAccountPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_subaddrIndices( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_PendingTransaction_subaddrIndices( + pendingTx_ptr, + separator, + ); + } + + late final _WOWNERO_PendingTransaction_subaddrIndicesPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'WOWNERO_PendingTransaction_subaddrIndices'); + late final _WOWNERO_PendingTransaction_subaddrIndices = + _WOWNERO_PendingTransaction_subaddrIndicesPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_multisigSignData( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_multisigSignData( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_multisigSignDataPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_PendingTransaction_multisigSignData'); + late final _WOWNERO_PendingTransaction_multisigSignData = + _WOWNERO_PendingTransaction_multisigSignDataPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void WOWNERO_PendingTransaction_signMultisigTx( + ffi.Pointer pendingTx_ptr, + ) { + return _WOWNERO_PendingTransaction_signMultisigTx( + pendingTx_ptr, + ); + } + + late final _WOWNERO_PendingTransaction_signMultisigTxPtr = + _lookup)>>( + 'WOWNERO_PendingTransaction_signMultisigTx'); + late final _WOWNERO_PendingTransaction_signMultisigTx = + _WOWNERO_PendingTransaction_signMultisigTxPtr.asFunction< + void Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_signersKeys( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_PendingTransaction_signersKeys( + pendingTx_ptr, + separator, + ); + } + + late final _WOWNERO_PendingTransaction_signersKeysPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'WOWNERO_PendingTransaction_signersKeys'); + late final _WOWNERO_PendingTransaction_signersKeys = + _WOWNERO_PendingTransaction_signersKeysPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_PendingTransaction_hex( + ffi.Pointer pendingTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_PendingTransaction_hex( + pendingTx_ptr, + separator, + ); + } + + late final _WOWNERO_PendingTransaction_hexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_PendingTransaction_hex'); + late final _WOWNERO_PendingTransaction_hex = + _WOWNERO_PendingTransaction_hexPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_UnsignedTransaction_status( + ffi.Pointer unsignedTx_ptr, + ) { + return _WOWNERO_UnsignedTransaction_status( + unsignedTx_ptr, + ); + } + + late final _WOWNERO_UnsignedTransaction_statusPtr = + _lookup)>>( + 'WOWNERO_UnsignedTransaction_status'); + late final _WOWNERO_UnsignedTransaction_status = + _WOWNERO_UnsignedTransaction_statusPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_errorString( + ffi.Pointer unsignedTx_ptr, + ) { + return _WOWNERO_UnsignedTransaction_errorString( + unsignedTx_ptr, + ); + } + + late final _WOWNERO_UnsignedTransaction_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_UnsignedTransaction_errorString'); + late final _WOWNERO_UnsignedTransaction_errorString = + _WOWNERO_UnsignedTransaction_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_amount( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_UnsignedTransaction_amount( + unsignedTx_ptr, + separator, + ); + } + + late final _WOWNERO_UnsignedTransaction_amountPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_UnsignedTransaction_amount'); + late final _WOWNERO_UnsignedTransaction_amount = + _WOWNERO_UnsignedTransaction_amountPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_fee( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_UnsignedTransaction_fee( + unsignedTx_ptr, + separator, + ); + } + + late final _WOWNERO_UnsignedTransaction_feePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_UnsignedTransaction_fee'); + late final _WOWNERO_UnsignedTransaction_fee = + _WOWNERO_UnsignedTransaction_feePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_mixin( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_UnsignedTransaction_mixin( + unsignedTx_ptr, + separator, + ); + } + + late final _WOWNERO_UnsignedTransaction_mixinPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_UnsignedTransaction_mixin'); + late final _WOWNERO_UnsignedTransaction_mixin = + _WOWNERO_UnsignedTransaction_mixinPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_confirmationMessage( + ffi.Pointer unsignedTx_ptr, + ) { + return _WOWNERO_UnsignedTransaction_confirmationMessage( + unsignedTx_ptr, + ); + } + + late final _WOWNERO_UnsignedTransaction_confirmationMessagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_UnsignedTransaction_confirmationMessage'); + late final _WOWNERO_UnsignedTransaction_confirmationMessage = + _WOWNERO_UnsignedTransaction_confirmationMessagePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_paymentId( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_UnsignedTransaction_paymentId( + unsignedTx_ptr, + separator, + ); + } + + late final _WOWNERO_UnsignedTransaction_paymentIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_UnsignedTransaction_paymentId'); + late final _WOWNERO_UnsignedTransaction_paymentId = + _WOWNERO_UnsignedTransaction_paymentIdPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_UnsignedTransaction_recipientAddress( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_UnsignedTransaction_recipientAddress( + unsignedTx_ptr, + separator, + ); + } + + late final _WOWNERO_UnsignedTransaction_recipientAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'WOWNERO_UnsignedTransaction_recipientAddress'); + late final _WOWNERO_UnsignedTransaction_recipientAddress = + _WOWNERO_UnsignedTransaction_recipientAddressPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_UnsignedTransaction_minMixinCount( + ffi.Pointer unsignedTx_ptr, + ) { + return _WOWNERO_UnsignedTransaction_minMixinCount( + unsignedTx_ptr, + ); + } + + late final _WOWNERO_UnsignedTransaction_minMixinCountPtr = + _lookup)>>( + 'WOWNERO_UnsignedTransaction_minMixinCount'); + late final _WOWNERO_UnsignedTransaction_minMixinCount = + _WOWNERO_UnsignedTransaction_minMixinCountPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_UnsignedTransaction_txCount( + ffi.Pointer unsignedTx_ptr, + ) { + return _WOWNERO_UnsignedTransaction_txCount( + unsignedTx_ptr, + ); + } + + late final _WOWNERO_UnsignedTransaction_txCountPtr = + _lookup)>>( + 'WOWNERO_UnsignedTransaction_txCount'); + late final _WOWNERO_UnsignedTransaction_txCount = + _WOWNERO_UnsignedTransaction_txCountPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool WOWNERO_UnsignedTransaction_sign( + ffi.Pointer unsignedTx_ptr, + ffi.Pointer signedFileName, + ) { + return _WOWNERO_UnsignedTransaction_sign( + unsignedTx_ptr, + signedFileName, + ); + } + + late final _WOWNERO_UnsignedTransaction_signPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_UnsignedTransaction_sign'); + late final _WOWNERO_UnsignedTransaction_sign = + _WOWNERO_UnsignedTransaction_signPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_direction( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_direction( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_directionPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_direction'); + late final _WOWNERO_TransactionInfo_direction = + _WOWNERO_TransactionInfo_directionPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool WOWNERO_TransactionInfo_isPending( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_isPending( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_isPendingPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_isPending'); + late final _WOWNERO_TransactionInfo_isPending = + _WOWNERO_TransactionInfo_isPendingPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_TransactionInfo_isFailed( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_isFailed( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_isFailedPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_isFailed'); + late final _WOWNERO_TransactionInfo_isFailed = + _WOWNERO_TransactionInfo_isFailedPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_TransactionInfo_isCoinbase( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_isCoinbase( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_isCoinbasePtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_isCoinbase'); + late final _WOWNERO_TransactionInfo_isCoinbase = + _WOWNERO_TransactionInfo_isCoinbasePtr.asFunction< + bool Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_amount( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_amount( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_amountPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_amount'); + late final _WOWNERO_TransactionInfo_amount = + _WOWNERO_TransactionInfo_amountPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_fee( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_fee( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_feePtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_fee'); + late final _WOWNERO_TransactionInfo_fee = _WOWNERO_TransactionInfo_feePtr + .asFunction)>(); + + int WOWNERO_TransactionInfo_blockHeight( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_blockHeight( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_blockHeightPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_blockHeight'); + late final _WOWNERO_TransactionInfo_blockHeight = + _WOWNERO_TransactionInfo_blockHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_TransactionInfo_description( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_description( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_descriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_TransactionInfo_description'); + late final _WOWNERO_TransactionInfo_description = + _WOWNERO_TransactionInfo_descriptionPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_TransactionInfo_subaddrIndex( + ffi.Pointer txInfo_ptr, + ffi.Pointer separator, + ) { + return _WOWNERO_TransactionInfo_subaddrIndex( + txInfo_ptr, + separator, + ); + } + + late final _WOWNERO_TransactionInfo_subaddrIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_TransactionInfo_subaddrIndex'); + late final _WOWNERO_TransactionInfo_subaddrIndex = + _WOWNERO_TransactionInfo_subaddrIndexPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_subaddrAccount( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_subaddrAccount( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_subaddrAccountPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_subaddrAccount'); + late final _WOWNERO_TransactionInfo_subaddrAccount = + _WOWNERO_TransactionInfo_subaddrAccountPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_TransactionInfo_label( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_label( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_labelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_TransactionInfo_label'); + late final _WOWNERO_TransactionInfo_label = _WOWNERO_TransactionInfo_labelPtr + .asFunction Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_confirmations( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_confirmations( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_confirmationsPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_confirmations'); + late final _WOWNERO_TransactionInfo_confirmations = + _WOWNERO_TransactionInfo_confirmationsPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_unlockTime( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_unlockTime( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_unlockTimePtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_unlockTime'); + late final _WOWNERO_TransactionInfo_unlockTime = + _WOWNERO_TransactionInfo_unlockTimePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_TransactionInfo_hash( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_hash( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_hashPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_TransactionInfo_hash'); + late final _WOWNERO_TransactionInfo_hash = _WOWNERO_TransactionInfo_hashPtr + .asFunction Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_timestamp( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_timestamp( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_timestampPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_timestamp'); + late final _WOWNERO_TransactionInfo_timestamp = + _WOWNERO_TransactionInfo_timestampPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_TransactionInfo_paymentId( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_paymentId( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_paymentIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_TransactionInfo_paymentId'); + late final _WOWNERO_TransactionInfo_paymentId = + _WOWNERO_TransactionInfo_paymentIdPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_transfers_count( + ffi.Pointer txInfo_ptr, + ) { + return _WOWNERO_TransactionInfo_transfers_count( + txInfo_ptr, + ); + } + + late final _WOWNERO_TransactionInfo_transfers_countPtr = + _lookup)>>( + 'WOWNERO_TransactionInfo_transfers_count'); + late final _WOWNERO_TransactionInfo_transfers_count = + _WOWNERO_TransactionInfo_transfers_countPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_TransactionInfo_transfers_amount( + ffi.Pointer txInfo_ptr, + int index, + ) { + return _WOWNERO_TransactionInfo_transfers_amount( + txInfo_ptr, + index, + ); + } + + late final _WOWNERO_TransactionInfo_transfers_amountPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'WOWNERO_TransactionInfo_transfers_amount'); + late final _WOWNERO_TransactionInfo_transfers_amount = + _WOWNERO_TransactionInfo_transfers_amountPtr.asFunction< + int Function(ffi.Pointer, int)>(); + + ffi.Pointer WOWNERO_TransactionInfo_transfers_address( + ffi.Pointer txInfo_ptr, + int address, + ) { + return _WOWNERO_TransactionInfo_transfers_address( + txInfo_ptr, + address, + ); + } + + late final _WOWNERO_TransactionInfo_transfers_addressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('WOWNERO_TransactionInfo_transfers_address'); + late final _WOWNERO_TransactionInfo_transfers_address = + _WOWNERO_TransactionInfo_transfers_addressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int WOWNERO_TransactionHistory_count( + ffi.Pointer txHistory_ptr, + ) { + return _WOWNERO_TransactionHistory_count( + txHistory_ptr, + ); + } + + late final _WOWNERO_TransactionHistory_countPtr = + _lookup)>>( + 'WOWNERO_TransactionHistory_count'); + late final _WOWNERO_TransactionHistory_count = + _WOWNERO_TransactionHistory_countPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_TransactionHistory_transaction( + ffi.Pointer txHistory_ptr, + int index, + ) { + return _WOWNERO_TransactionHistory_transaction( + txHistory_ptr, + index, + ); + } + + late final _WOWNERO_TransactionHistory_transactionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('WOWNERO_TransactionHistory_transaction'); + late final _WOWNERO_TransactionHistory_transaction = + _WOWNERO_TransactionHistory_transactionPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + ffi.Pointer WOWNERO_TransactionHistory_transactionById( + ffi.Pointer txHistory_ptr, + ffi.Pointer id, + ) { + return _WOWNERO_TransactionHistory_transactionById( + txHistory_ptr, + id, + ); + } + + late final _WOWNERO_TransactionHistory_transactionByIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>>( + 'WOWNERO_TransactionHistory_transactionById'); + late final _WOWNERO_TransactionHistory_transactionById = + _WOWNERO_TransactionHistory_transactionByIdPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + void WOWNERO_TransactionHistory_refresh( + ffi.Pointer txHistory_ptr, + ) { + return _WOWNERO_TransactionHistory_refresh( + txHistory_ptr, + ); + } + + late final _WOWNERO_TransactionHistory_refreshPtr = + _lookup)>>( + 'WOWNERO_TransactionHistory_refresh'); + late final _WOWNERO_TransactionHistory_refresh = + _WOWNERO_TransactionHistory_refreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + void WOWNERO_TransactionHistory_setTxNote( + ffi.Pointer txHistory_ptr, + ffi.Pointer txid, + ffi.Pointer note, + ) { + return _WOWNERO_TransactionHistory_setTxNote( + txHistory_ptr, + txid, + note, + ); + } + + late final _WOWNERO_TransactionHistory_setTxNotePtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('WOWNERO_TransactionHistory_setTxNote'); + late final _WOWNERO_TransactionHistory_setTxNote = + _WOWNERO_TransactionHistory_setTxNotePtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_AddressBookRow_extra( + ffi.Pointer addressBookRow_ptr, + ) { + return _WOWNERO_AddressBookRow_extra( + addressBookRow_ptr, + ); + } + + late final _WOWNERO_AddressBookRow_extraPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_AddressBookRow_extra'); + late final _WOWNERO_AddressBookRow_extra = _WOWNERO_AddressBookRow_extraPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_AddressBookRow_getAddress( + ffi.Pointer addressBookRow_ptr, + ) { + return _WOWNERO_AddressBookRow_getAddress( + addressBookRow_ptr, + ); + } + + late final _WOWNERO_AddressBookRow_getAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_AddressBookRow_getAddress'); + late final _WOWNERO_AddressBookRow_getAddress = + _WOWNERO_AddressBookRow_getAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_AddressBookRow_getDescription( + ffi.Pointer addressBookRow_ptr, + ) { + return _WOWNERO_AddressBookRow_getDescription( + addressBookRow_ptr, + ); + } + + late final _WOWNERO_AddressBookRow_getDescriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_AddressBookRow_getDescription'); + late final _WOWNERO_AddressBookRow_getDescription = + _WOWNERO_AddressBookRow_getDescriptionPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_AddressBookRow_getPaymentId( + ffi.Pointer addressBookRow_ptr, + ) { + return _WOWNERO_AddressBookRow_getPaymentId( + addressBookRow_ptr, + ); + } + + late final _WOWNERO_AddressBookRow_getPaymentIdPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_AddressBookRow_getPaymentId'); + late final _WOWNERO_AddressBookRow_getPaymentId = + _WOWNERO_AddressBookRow_getPaymentIdPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_AddressBookRow_getRowId( + ffi.Pointer addressBookRow_ptr, + ) { + return _WOWNERO_AddressBookRow_getRowId( + addressBookRow_ptr, + ); + } + + late final _WOWNERO_AddressBookRow_getRowIdPtr = + _lookup)>>( + 'WOWNERO_AddressBookRow_getRowId'); + late final _WOWNERO_AddressBookRow_getRowId = + _WOWNERO_AddressBookRow_getRowIdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_AddressBook_getAll_size( + ffi.Pointer addressBook_ptr, + ) { + return _WOWNERO_AddressBook_getAll_size( + addressBook_ptr, + ); + } + + late final _WOWNERO_AddressBook_getAll_sizePtr = + _lookup)>>( + 'WOWNERO_AddressBook_getAll_size'); + late final _WOWNERO_AddressBook_getAll_size = + _WOWNERO_AddressBook_getAll_sizePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_AddressBook_getAll_byIndex( + ffi.Pointer addressBook_ptr, + int index, + ) { + return _WOWNERO_AddressBook_getAll_byIndex( + addressBook_ptr, + index, + ); + } + + late final _WOWNERO_AddressBook_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('WOWNERO_AddressBook_getAll_byIndex'); + late final _WOWNERO_AddressBook_getAll_byIndex = + _WOWNERO_AddressBook_getAll_byIndexPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + bool WOWNERO_AddressBook_addRow( + ffi.Pointer addressBook_ptr, + ffi.Pointer dst_addr, + ffi.Pointer payment_id, + ffi.Pointer 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.Pointer, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_AddressBook_addRow'); + late final _WOWNERO_AddressBook_addRow = + _WOWNERO_AddressBook_addRowPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_AddressBook_deleteRow( + ffi.Pointer addressBook_ptr, + int rowId, + ) { + return _WOWNERO_AddressBook_deleteRow( + addressBook_ptr, + rowId, + ); + } + + late final _WOWNERO_AddressBook_deleteRowPtr = _lookup< + ffi + .NativeFunction, ffi.Size)>>( + 'WOWNERO_AddressBook_deleteRow'); + late final _WOWNERO_AddressBook_deleteRow = _WOWNERO_AddressBook_deleteRowPtr + .asFunction, int)>(); + + bool WOWNERO_AddressBook_setDescription( + ffi.Pointer addressBook_ptr, + int rowId, + ffi.Pointer description, + ) { + return _WOWNERO_AddressBook_setDescription( + addressBook_ptr, + rowId, + description, + ); + } + + late final _WOWNERO_AddressBook_setDescriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, ffi.Size, + ffi.Pointer)>>('WOWNERO_AddressBook_setDescription'); + late final _WOWNERO_AddressBook_setDescription = + _WOWNERO_AddressBook_setDescriptionPtr.asFunction< + bool Function(ffi.Pointer, int, ffi.Pointer)>(); + + void WOWNERO_AddressBook_refresh( + ffi.Pointer addressBook_ptr, + ) { + return _WOWNERO_AddressBook_refresh( + addressBook_ptr, + ); + } + + late final _WOWNERO_AddressBook_refreshPtr = + _lookup)>>( + 'WOWNERO_AddressBook_refresh'); + late final _WOWNERO_AddressBook_refresh = _WOWNERO_AddressBook_refreshPtr + .asFunction)>(); + + ffi.Pointer WOWNERO_AddressBook_errorString( + ffi.Pointer addressBook_ptr, + ) { + return _WOWNERO_AddressBook_errorString( + addressBook_ptr, + ); + } + + late final _WOWNERO_AddressBook_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_AddressBook_errorString'); + late final _WOWNERO_AddressBook_errorString = + _WOWNERO_AddressBook_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_AddressBook_errorCode( + ffi.Pointer addressBook_ptr, + ) { + return _WOWNERO_AddressBook_errorCode( + addressBook_ptr, + ); + } + + late final _WOWNERO_AddressBook_errorCodePtr = + _lookup)>>( + 'WOWNERO_AddressBook_errorCode'); + late final _WOWNERO_AddressBook_errorCode = _WOWNERO_AddressBook_errorCodePtr + .asFunction)>(); + + int WOWNERO_AddressBook_lookupPaymentID( + ffi.Pointer addressBook_ptr, + ffi.Pointer payment_id, + ) { + return _WOWNERO_AddressBook_lookupPaymentID( + addressBook_ptr, + payment_id, + ); + } + + late final _WOWNERO_AddressBook_lookupPaymentIDPtr = _lookup< + ffi.NativeFunction< + ffi.Int Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_AddressBook_lookupPaymentID'); + late final _WOWNERO_AddressBook_lookupPaymentID = + _WOWNERO_AddressBook_lookupPaymentIDPtr.asFunction< + int Function(ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_CoinsInfo_blockHeight( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_blockHeight( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_blockHeightPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_blockHeight'); + late final _WOWNERO_CoinsInfo_blockHeight = _WOWNERO_CoinsInfo_blockHeightPtr + .asFunction)>(); + + ffi.Pointer WOWNERO_CoinsInfo_hash( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_hash( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_hashPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_CoinsInfo_hash'); + late final _WOWNERO_CoinsInfo_hash = _WOWNERO_CoinsInfo_hashPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_CoinsInfo_internalOutputIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_internalOutputIndex( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_internalOutputIndexPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_internalOutputIndex'); + late final _WOWNERO_CoinsInfo_internalOutputIndex = + _WOWNERO_CoinsInfo_internalOutputIndexPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_CoinsInfo_globalOutputIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_globalOutputIndex( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_globalOutputIndexPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_globalOutputIndex'); + late final _WOWNERO_CoinsInfo_globalOutputIndex = + _WOWNERO_CoinsInfo_globalOutputIndexPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool WOWNERO_CoinsInfo_spent( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_spent( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_spentPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_spent'); + late final _WOWNERO_CoinsInfo_spent = _WOWNERO_CoinsInfo_spentPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_CoinsInfo_frozen( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_frozen( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_frozenPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_frozen'); + late final _WOWNERO_CoinsInfo_frozen = _WOWNERO_CoinsInfo_frozenPtr + .asFunction)>(); + + int WOWNERO_CoinsInfo_spentHeight( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_spentHeight( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_spentHeightPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_spentHeight'); + late final _WOWNERO_CoinsInfo_spentHeight = _WOWNERO_CoinsInfo_spentHeightPtr + .asFunction)>(); + + int WOWNERO_CoinsInfo_amount( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_amount( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_amountPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_amount'); + late final _WOWNERO_CoinsInfo_amount = _WOWNERO_CoinsInfo_amountPtr + .asFunction)>(); + + bool WOWNERO_CoinsInfo_rct( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_rct( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_rctPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_rct'); + late final _WOWNERO_CoinsInfo_rct = _WOWNERO_CoinsInfo_rctPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_CoinsInfo_keyImageKnown( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_keyImageKnown( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_keyImageKnownPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_keyImageKnown'); + late final _WOWNERO_CoinsInfo_keyImageKnown = + _WOWNERO_CoinsInfo_keyImageKnownPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int WOWNERO_CoinsInfo_pkIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_pkIndex( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_pkIndexPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_pkIndex'); + late final _WOWNERO_CoinsInfo_pkIndex = _WOWNERO_CoinsInfo_pkIndexPtr + .asFunction)>(); + + int WOWNERO_CoinsInfo_subaddrIndex( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_subaddrIndex( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_subaddrIndexPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_subaddrIndex'); + late final _WOWNERO_CoinsInfo_subaddrIndex = + _WOWNERO_CoinsInfo_subaddrIndexPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_CoinsInfo_subaddrAccount( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_subaddrAccount( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_subaddrAccountPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_subaddrAccount'); + late final _WOWNERO_CoinsInfo_subaddrAccount = + _WOWNERO_CoinsInfo_subaddrAccountPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_CoinsInfo_address( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_address( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_addressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_CoinsInfo_address'); + late final _WOWNERO_CoinsInfo_address = _WOWNERO_CoinsInfo_addressPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_CoinsInfo_addressLabel( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_addressLabel( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_addressLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_CoinsInfo_addressLabel'); + late final _WOWNERO_CoinsInfo_addressLabel = + _WOWNERO_CoinsInfo_addressLabelPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_CoinsInfo_keyImage( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_keyImage( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_keyImagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_CoinsInfo_keyImage'); + late final _WOWNERO_CoinsInfo_keyImage = _WOWNERO_CoinsInfo_keyImagePtr + .asFunction Function(ffi.Pointer)>(); + + int WOWNERO_CoinsInfo_unlockTime( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_unlockTime( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_unlockTimePtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_unlockTime'); + late final _WOWNERO_CoinsInfo_unlockTime = _WOWNERO_CoinsInfo_unlockTimePtr + .asFunction)>(); + + bool WOWNERO_CoinsInfo_unlocked( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_unlocked( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_unlockedPtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_unlocked'); + late final _WOWNERO_CoinsInfo_unlocked = _WOWNERO_CoinsInfo_unlockedPtr + .asFunction)>(); + + ffi.Pointer WOWNERO_CoinsInfo_pubKey( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_pubKey( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_pubKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_CoinsInfo_pubKey'); + late final _WOWNERO_CoinsInfo_pubKey = _WOWNERO_CoinsInfo_pubKeyPtr + .asFunction Function(ffi.Pointer)>(); + + bool WOWNERO_CoinsInfo_coinbase( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_coinbase( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_coinbasePtr = + _lookup)>>( + 'WOWNERO_CoinsInfo_coinbase'); + late final _WOWNERO_CoinsInfo_coinbase = _WOWNERO_CoinsInfo_coinbasePtr + .asFunction)>(); + + ffi.Pointer WOWNERO_CoinsInfo_description( + ffi.Pointer coinsInfo_ptr, + ) { + return _WOWNERO_CoinsInfo_description( + coinsInfo_ptr, + ); + } + + late final _WOWNERO_CoinsInfo_descriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_CoinsInfo_description'); + late final _WOWNERO_CoinsInfo_description = _WOWNERO_CoinsInfo_descriptionPtr + .asFunction Function(ffi.Pointer)>(); + + int WOWNERO_Coins_count( + ffi.Pointer coins_ptr, + ) { + return _WOWNERO_Coins_count( + coins_ptr, + ); + } + + late final _WOWNERO_Coins_countPtr = + _lookup)>>( + 'WOWNERO_Coins_count'); + late final _WOWNERO_Coins_count = + _WOWNERO_Coins_countPtr.asFunction)>(); + + ffi.Pointer WOWNERO_Coins_coin( + ffi.Pointer coins_ptr, + int index, + ) { + return _WOWNERO_Coins_coin( + coins_ptr, + index, + ); + } + + late final _WOWNERO_Coins_coinPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Int)>>('WOWNERO_Coins_coin'); + late final _WOWNERO_Coins_coin = _WOWNERO_Coins_coinPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int WOWNERO_Coins_getAll_size( + ffi.Pointer coins_ptr, + ) { + return _WOWNERO_Coins_getAll_size( + coins_ptr, + ); + } + + late final _WOWNERO_Coins_getAll_sizePtr = + _lookup)>>( + 'WOWNERO_Coins_getAll_size'); + late final _WOWNERO_Coins_getAll_size = _WOWNERO_Coins_getAll_sizePtr + .asFunction)>(); + + ffi.Pointer WOWNERO_Coins_getAll_byIndex( + ffi.Pointer coins_ptr, + int index, + ) { + return _WOWNERO_Coins_getAll_byIndex( + coins_ptr, + index, + ); + } + + late final _WOWNERO_Coins_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Int)>>('WOWNERO_Coins_getAll_byIndex'); + late final _WOWNERO_Coins_getAll_byIndex = _WOWNERO_Coins_getAll_byIndexPtr + .asFunction Function(ffi.Pointer, int)>(); + + void WOWNERO_Coins_refresh( + ffi.Pointer coins_ptr, + ) { + return _WOWNERO_Coins_refresh( + coins_ptr, + ); + } + + late final _WOWNERO_Coins_refreshPtr = + _lookup)>>( + 'WOWNERO_Coins_refresh'); + late final _WOWNERO_Coins_refresh = _WOWNERO_Coins_refreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + void WOWNERO_Coins_setFrozenByPublicKey( + ffi.Pointer coins_ptr, + ffi.Pointer public_key, + ) { + return _WOWNERO_Coins_setFrozenByPublicKey( + coins_ptr, + public_key, + ); + } + + late final _WOWNERO_Coins_setFrozenByPublicKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Coins_setFrozenByPublicKey'); + late final _WOWNERO_Coins_setFrozenByPublicKey = + _WOWNERO_Coins_setFrozenByPublicKeyPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + void WOWNERO_Coins_setFrozen( + ffi.Pointer coins_ptr, + int index, + ) { + return _WOWNERO_Coins_setFrozen( + coins_ptr, + index, + ); + } + + late final _WOWNERO_Coins_setFrozenPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'WOWNERO_Coins_setFrozen'); + late final _WOWNERO_Coins_setFrozen = _WOWNERO_Coins_setFrozenPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + void WOWNERO_Coins_thaw( + ffi.Pointer coins_ptr, + int index, + ) { + return _WOWNERO_Coins_thaw( + coins_ptr, + index, + ); + } + + late final _WOWNERO_Coins_thawPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'WOWNERO_Coins_thaw'); + late final _WOWNERO_Coins_thaw = _WOWNERO_Coins_thawPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + void WOWNERO_Coins_thawByPublicKey( + ffi.Pointer coins_ptr, + ffi.Pointer public_key, + ) { + return _WOWNERO_Coins_thawByPublicKey( + coins_ptr, + public_key, + ); + } + + late final _WOWNERO_Coins_thawByPublicKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Coins_thawByPublicKey'); + late final _WOWNERO_Coins_thawByPublicKey = + _WOWNERO_Coins_thawByPublicKeyPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Coins_isTransferUnlocked( + ffi.Pointer 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.Uint64, + ffi.Uint64)>>('WOWNERO_Coins_isTransferUnlocked'); + late final _WOWNERO_Coins_isTransferUnlocked = + _WOWNERO_Coins_isTransferUnlockedPtr.asFunction< + bool Function(ffi.Pointer, int, int)>(); + + void WOWNERO_Coins_setDescription( + ffi.Pointer coins_ptr, + ffi.Pointer public_key, + ffi.Pointer description, + ) { + return _WOWNERO_Coins_setDescription( + coins_ptr, + public_key, + description, + ); + } + + late final _WOWNERO_Coins_setDescriptionPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Coins_setDescription'); + late final _WOWNERO_Coins_setDescription = + _WOWNERO_Coins_setDescriptionPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressRow_extra( + ffi.Pointer subaddressRow_ptr, + ) { + return _WOWNERO_SubaddressRow_extra( + subaddressRow_ptr, + ); + } + + late final _WOWNERO_SubaddressRow_extraPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_SubaddressRow_extra'); + late final _WOWNERO_SubaddressRow_extra = _WOWNERO_SubaddressRow_extraPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressRow_getAddress( + ffi.Pointer subaddressRow_ptr, + ) { + return _WOWNERO_SubaddressRow_getAddress( + subaddressRow_ptr, + ); + } + + late final _WOWNERO_SubaddressRow_getAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_SubaddressRow_getAddress'); + late final _WOWNERO_SubaddressRow_getAddress = + _WOWNERO_SubaddressRow_getAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressRow_getLabel( + ffi.Pointer subaddressRow_ptr, + ) { + return _WOWNERO_SubaddressRow_getLabel( + subaddressRow_ptr, + ); + } + + late final _WOWNERO_SubaddressRow_getLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_SubaddressRow_getLabel'); + late final _WOWNERO_SubaddressRow_getLabel = + _WOWNERO_SubaddressRow_getLabelPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_SubaddressRow_getRowId( + ffi.Pointer subaddressRow_ptr, + ) { + return _WOWNERO_SubaddressRow_getRowId( + subaddressRow_ptr, + ); + } + + late final _WOWNERO_SubaddressRow_getRowIdPtr = + _lookup)>>( + 'WOWNERO_SubaddressRow_getRowId'); + late final _WOWNERO_SubaddressRow_getRowId = + _WOWNERO_SubaddressRow_getRowIdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Subaddress_getAll_size( + ffi.Pointer subaddress_ptr, + ) { + return _WOWNERO_Subaddress_getAll_size( + subaddress_ptr, + ); + } + + late final _WOWNERO_Subaddress_getAll_sizePtr = + _lookup)>>( + 'WOWNERO_Subaddress_getAll_size'); + late final _WOWNERO_Subaddress_getAll_size = + _WOWNERO_Subaddress_getAll_sizePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Subaddress_getAll_byIndex( + ffi.Pointer subaddress_ptr, + int index, + ) { + return _WOWNERO_Subaddress_getAll_byIndex( + subaddress_ptr, + index, + ); + } + + late final _WOWNERO_Subaddress_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('WOWNERO_Subaddress_getAll_byIndex'); + late final _WOWNERO_Subaddress_getAll_byIndex = + _WOWNERO_Subaddress_getAll_byIndexPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + void WOWNERO_Subaddress_addRow( + ffi.Pointer subaddress_ptr, + int accountIndex, + ffi.Pointer label, + ) { + return _WOWNERO_Subaddress_addRow( + subaddress_ptr, + accountIndex, + label, + ); + } + + late final _WOWNERO_Subaddress_addRowPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, + ffi.Pointer)>>('WOWNERO_Subaddress_addRow'); + late final _WOWNERO_Subaddress_addRow = + _WOWNERO_Subaddress_addRowPtr.asFunction< + void Function(ffi.Pointer, int, ffi.Pointer)>(); + + void WOWNERO_Subaddress_setLabel( + ffi.Pointer subaddress_ptr, + int accountIndex, + int addressIndex, + ffi.Pointer label, + ) { + return _WOWNERO_Subaddress_setLabel( + subaddress_ptr, + accountIndex, + addressIndex, + label, + ); + } + + late final _WOWNERO_Subaddress_setLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, ffi.Uint32, + ffi.Pointer)>>('WOWNERO_Subaddress_setLabel'); + late final _WOWNERO_Subaddress_setLabel = + _WOWNERO_Subaddress_setLabelPtr.asFunction< + void Function( + ffi.Pointer, int, int, ffi.Pointer)>(); + + void WOWNERO_Subaddress_refresh( + ffi.Pointer 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.Uint32)>>('WOWNERO_Subaddress_refresh'); + late final _WOWNERO_Subaddress_refresh = _WOWNERO_Subaddress_refreshPtr + .asFunction, int)>(); + + ffi.Pointer WOWNERO_SubaddressAccountRow_extra( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _WOWNERO_SubaddressAccountRow_extra( + subaddressAccountRow_ptr, + ); + } + + late final _WOWNERO_SubaddressAccountRow_extraPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_SubaddressAccountRow_extra'); + late final _WOWNERO_SubaddressAccountRow_extra = + _WOWNERO_SubaddressAccountRow_extraPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressAccountRow_getAddress( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _WOWNERO_SubaddressAccountRow_getAddress( + subaddressAccountRow_ptr, + ); + } + + late final _WOWNERO_SubaddressAccountRow_getAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_SubaddressAccountRow_getAddress'); + late final _WOWNERO_SubaddressAccountRow_getAddress = + _WOWNERO_SubaddressAccountRow_getAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressAccountRow_getLabel( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _WOWNERO_SubaddressAccountRow_getLabel( + subaddressAccountRow_ptr, + ); + } + + late final _WOWNERO_SubaddressAccountRow_getLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_SubaddressAccountRow_getLabel'); + late final _WOWNERO_SubaddressAccountRow_getLabel = + _WOWNERO_SubaddressAccountRow_getLabelPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressAccountRow_getBalance( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _WOWNERO_SubaddressAccountRow_getBalance( + subaddressAccountRow_ptr, + ); + } + + late final _WOWNERO_SubaddressAccountRow_getBalancePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_SubaddressAccountRow_getBalance'); + late final _WOWNERO_SubaddressAccountRow_getBalance = + _WOWNERO_SubaddressAccountRow_getBalancePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressAccountRow_getUnlockedBalance( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _WOWNERO_SubaddressAccountRow_getUnlockedBalance( + subaddressAccountRow_ptr, + ); + } + + late final _WOWNERO_SubaddressAccountRow_getUnlockedBalancePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_SubaddressAccountRow_getUnlockedBalance'); + late final _WOWNERO_SubaddressAccountRow_getUnlockedBalance = + _WOWNERO_SubaddressAccountRow_getUnlockedBalancePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_SubaddressAccountRow_getRowId( + ffi.Pointer subaddressAccountRow_ptr, + ) { + return _WOWNERO_SubaddressAccountRow_getRowId( + subaddressAccountRow_ptr, + ); + } + + late final _WOWNERO_SubaddressAccountRow_getRowIdPtr = + _lookup)>>( + 'WOWNERO_SubaddressAccountRow_getRowId'); + late final _WOWNERO_SubaddressAccountRow_getRowId = + _WOWNERO_SubaddressAccountRow_getRowIdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_SubaddressAccount_getAll_size( + ffi.Pointer subaddressAccount_ptr, + ) { + return _WOWNERO_SubaddressAccount_getAll_size( + subaddressAccount_ptr, + ); + } + + late final _WOWNERO_SubaddressAccount_getAll_sizePtr = + _lookup)>>( + 'WOWNERO_SubaddressAccount_getAll_size'); + late final _WOWNERO_SubaddressAccount_getAll_size = + _WOWNERO_SubaddressAccount_getAll_sizePtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_SubaddressAccount_getAll_byIndex( + ffi.Pointer subaddressAccount_ptr, + int index, + ) { + return _WOWNERO_SubaddressAccount_getAll_byIndex( + subaddressAccount_ptr, + index, + ); + } + + late final _WOWNERO_SubaddressAccount_getAll_byIndexPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('WOWNERO_SubaddressAccount_getAll_byIndex'); + late final _WOWNERO_SubaddressAccount_getAll_byIndex = + _WOWNERO_SubaddressAccount_getAll_byIndexPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + void WOWNERO_SubaddressAccount_addRow( + ffi.Pointer subaddressAccount_ptr, + ffi.Pointer label, + ) { + return _WOWNERO_SubaddressAccount_addRow( + subaddressAccount_ptr, + label, + ); + } + + late final _WOWNERO_SubaddressAccount_addRowPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_SubaddressAccount_addRow'); + late final _WOWNERO_SubaddressAccount_addRow = + _WOWNERO_SubaddressAccount_addRowPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + void WOWNERO_SubaddressAccount_setLabel( + ffi.Pointer subaddressAccount_ptr, + int accountIndex, + ffi.Pointer label, + ) { + return _WOWNERO_SubaddressAccount_setLabel( + subaddressAccount_ptr, + accountIndex, + label, + ); + } + + late final _WOWNERO_SubaddressAccount_setLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, + ffi.Pointer)>>('WOWNERO_SubaddressAccount_setLabel'); + late final _WOWNERO_SubaddressAccount_setLabel = + _WOWNERO_SubaddressAccount_setLabelPtr.asFunction< + void Function(ffi.Pointer, int, ffi.Pointer)>(); + + void WOWNERO_SubaddressAccount_refresh( + ffi.Pointer subaddressAccount_ptr, + ) { + return _WOWNERO_SubaddressAccount_refresh( + subaddressAccount_ptr, + ); + } + + late final _WOWNERO_SubaddressAccount_refreshPtr = + _lookup)>>( + 'WOWNERO_SubaddressAccount_refresh'); + late final _WOWNERO_SubaddressAccount_refresh = + _WOWNERO_SubaddressAccount_refreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + bool WOWNERO_MultisigState_isMultisig( + ffi.Pointer multisigState_ptr, + ) { + return _WOWNERO_MultisigState_isMultisig( + multisigState_ptr, + ); + } + + late final _WOWNERO_MultisigState_isMultisigPtr = + _lookup)>>( + 'WOWNERO_MultisigState_isMultisig'); + late final _WOWNERO_MultisigState_isMultisig = + _WOWNERO_MultisigState_isMultisigPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_MultisigState_isReady( + ffi.Pointer multisigState_ptr, + ) { + return _WOWNERO_MultisigState_isReady( + multisigState_ptr, + ); + } + + late final _WOWNERO_MultisigState_isReadyPtr = + _lookup)>>( + 'WOWNERO_MultisigState_isReady'); + late final _WOWNERO_MultisigState_isReady = _WOWNERO_MultisigState_isReadyPtr + .asFunction)>(); + + int WOWNERO_MultisigState_threshold( + ffi.Pointer multisigState_ptr, + ) { + return _WOWNERO_MultisigState_threshold( + multisigState_ptr, + ); + } + + late final _WOWNERO_MultisigState_thresholdPtr = + _lookup)>>( + 'WOWNERO_MultisigState_threshold'); + late final _WOWNERO_MultisigState_threshold = + _WOWNERO_MultisigState_thresholdPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_MultisigState_total( + ffi.Pointer multisigState_ptr, + ) { + return _WOWNERO_MultisigState_total( + multisigState_ptr, + ); + } + + late final _WOWNERO_MultisigState_totalPtr = + _lookup)>>( + 'WOWNERO_MultisigState_total'); + late final _WOWNERO_MultisigState_total = _WOWNERO_MultisigState_totalPtr + .asFunction)>(); + + bool WOWNERO_DeviceProgress_progress( + ffi.Pointer deviceProgress_ptr, + ) { + return _WOWNERO_DeviceProgress_progress( + deviceProgress_ptr, + ); + } + + late final _WOWNERO_DeviceProgress_progressPtr = + _lookup)>>( + 'WOWNERO_DeviceProgress_progress'); + late final _WOWNERO_DeviceProgress_progress = + _WOWNERO_DeviceProgress_progressPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_DeviceProgress_indeterminate( + ffi.Pointer deviceProgress_ptr, + ) { + return _WOWNERO_DeviceProgress_indeterminate( + deviceProgress_ptr, + ); + } + + late final _WOWNERO_DeviceProgress_indeterminatePtr = + _lookup)>>( + 'WOWNERO_DeviceProgress_indeterminate'); + late final _WOWNERO_DeviceProgress_indeterminate = + _WOWNERO_DeviceProgress_indeterminatePtr.asFunction< + bool Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_seed( + ffi.Pointer wallet_ptr, + ffi.Pointer seed_offset, + ) { + return _WOWNERO_Wallet_seed( + wallet_ptr, + seed_offset, + ); + } + + late final _WOWNERO_Wallet_seedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_seed'); + late final _WOWNERO_Wallet_seed = _WOWNERO_Wallet_seedPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getSeedLanguage( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getSeedLanguage( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getSeedLanguagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_getSeedLanguage'); + late final _WOWNERO_Wallet_getSeedLanguage = + _WOWNERO_Wallet_getSeedLanguagePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_setSeedLanguage( + ffi.Pointer wallet_ptr, + ffi.Pointer arg, + ) { + return _WOWNERO_Wallet_setSeedLanguage( + wallet_ptr, + arg, + ); + } + + late final _WOWNERO_Wallet_setSeedLanguagePtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setSeedLanguage'); + late final _WOWNERO_Wallet_setSeedLanguage = + _WOWNERO_Wallet_setSeedLanguagePtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_Wallet_status( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_status( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_statusPtr = + _lookup)>>( + 'WOWNERO_Wallet_status'); + late final _WOWNERO_Wallet_status = _WOWNERO_Wallet_statusPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_errorString( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_errorString( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_errorString'); + late final _WOWNERO_Wallet_errorString = _WOWNERO_Wallet_errorStringPtr + .asFunction Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_setPassword( + ffi.Pointer wallet_ptr, + ffi.Pointer password, + ) { + return _WOWNERO_Wallet_setPassword( + wallet_ptr, + password, + ); + } + + late final _WOWNERO_Wallet_setPasswordPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setPassword'); + late final _WOWNERO_Wallet_setPassword = + _WOWNERO_Wallet_setPasswordPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getPassword( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getPassword( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getPasswordPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_getPassword'); + late final _WOWNERO_Wallet_getPassword = _WOWNERO_Wallet_getPasswordPtr + .asFunction Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_setDevicePin( + ffi.Pointer wallet_ptr, + ffi.Pointer pin, + ) { + return _WOWNERO_Wallet_setDevicePin( + wallet_ptr, + pin, + ); + } + + late final _WOWNERO_Wallet_setDevicePinPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setDevicePin'); + late final _WOWNERO_Wallet_setDevicePin = + _WOWNERO_Wallet_setDevicePinPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_setDevicePassphrase( + ffi.Pointer wallet_ptr, + ffi.Pointer passphrase, + ) { + return _WOWNERO_Wallet_setDevicePassphrase( + wallet_ptr, + passphrase, + ); + } + + late final _WOWNERO_Wallet_setDevicePassphrasePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setDevicePassphrase'); + late final _WOWNERO_Wallet_setDevicePassphrase = + _WOWNERO_Wallet_setDevicePassphrasePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_address( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ) { + return _WOWNERO_Wallet_address( + wallet_ptr, + accountIndex, + addressIndex, + ); + } + + late final _WOWNERO_Wallet_addressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, ffi.Uint64, + ffi.Uint64)>>('WOWNERO_Wallet_address'); + late final _WOWNERO_Wallet_address = _WOWNERO_Wallet_addressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, int)>(); + + ffi.Pointer WOWNERO_Wallet_path( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_path( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_pathPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_path'); + late final _WOWNERO_Wallet_path = _WOWNERO_Wallet_pathPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_nettype( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_nettype( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_nettypePtr = + _lookup)>>( + 'WOWNERO_Wallet_nettype'); + late final _WOWNERO_Wallet_nettype = _WOWNERO_Wallet_nettypePtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_useForkRules( + ffi.Pointer 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.Uint8, + ffi.Int64)>>('WOWNERO_Wallet_useForkRules'); + late final _WOWNERO_Wallet_useForkRules = _WOWNERO_Wallet_useForkRulesPtr + .asFunction, int, int)>(); + + ffi.Pointer WOWNERO_Wallet_integratedAddress( + ffi.Pointer wallet_ptr, + ffi.Pointer payment_id, + ) { + return _WOWNERO_Wallet_integratedAddress( + wallet_ptr, + payment_id, + ); + } + + late final _WOWNERO_Wallet_integratedAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_integratedAddress'); + late final _WOWNERO_Wallet_integratedAddress = + _WOWNERO_Wallet_integratedAddressPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_secretViewKey( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_secretViewKey( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_secretViewKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_secretViewKey'); + late final _WOWNERO_Wallet_secretViewKey = _WOWNERO_Wallet_secretViewKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_publicViewKey( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_publicViewKey( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_publicViewKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_publicViewKey'); + late final _WOWNERO_Wallet_publicViewKey = _WOWNERO_Wallet_publicViewKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_secretSpendKey( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_secretSpendKey( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_secretSpendKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_secretSpendKey'); + late final _WOWNERO_Wallet_secretSpendKey = _WOWNERO_Wallet_secretSpendKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_publicSpendKey( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_publicSpendKey( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_publicSpendKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_publicSpendKey'); + late final _WOWNERO_Wallet_publicSpendKey = _WOWNERO_Wallet_publicSpendKeyPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_publicMultisigSignerKey( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_publicMultisigSignerKey( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_publicMultisigSignerKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer)>>( + 'WOWNERO_Wallet_publicMultisigSignerKey'); + late final _WOWNERO_Wallet_publicMultisigSignerKey = + _WOWNERO_Wallet_publicMultisigSignerKeyPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_stop( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_stop( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_stopPtr = + _lookup)>>( + 'WOWNERO_Wallet_stop'); + late final _WOWNERO_Wallet_stop = _WOWNERO_Wallet_stopPtr.asFunction< + void Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_store( + ffi.Pointer wallet_ptr, + ffi.Pointer path, + ) { + return _WOWNERO_Wallet_store( + wallet_ptr, + path, + ); + } + + late final _WOWNERO_Wallet_storePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_store'); + late final _WOWNERO_Wallet_store = _WOWNERO_Wallet_storePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_filename( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_filename( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_filenamePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_filename'); + late final _WOWNERO_Wallet_filename = _WOWNERO_Wallet_filenamePtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_keysFilename( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_keysFilename( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_keysFilenamePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_keysFilename'); + late final _WOWNERO_Wallet_keysFilename = _WOWNERO_Wallet_keysFilenamePtr + .asFunction Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_init( + ffi.Pointer wallet_ptr, + ffi.Pointer daemon_address, + int upper_transaction_size_limit, + ffi.Pointer daemon_username, + ffi.Pointer daemon_password, + bool use_ssl, + bool lightWallet, + ffi.Pointer 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.Pointer, + ffi.Uint64, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Bool, + ffi.Pointer)>>('WOWNERO_Wallet_init'); + late final _WOWNERO_Wallet_init = _WOWNERO_Wallet_initPtr.asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + bool, + bool, + ffi.Pointer)>(); + + bool WOWNERO_Wallet_createWatchOnly( + ffi.Pointer wallet_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + ) { + return _WOWNERO_Wallet_createWatchOnly( + wallet_ptr, + path, + password, + language, + ); + } + + late final _WOWNERO_Wallet_createWatchOnlyPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_createWatchOnly'); + late final _WOWNERO_Wallet_createWatchOnly = + _WOWNERO_Wallet_createWatchOnlyPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + void WOWNERO_Wallet_setRefreshFromBlockHeight( + ffi.Pointer 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.Uint64)>>('WOWNERO_Wallet_setRefreshFromBlockHeight'); + late final _WOWNERO_Wallet_setRefreshFromBlockHeight = + _WOWNERO_Wallet_setRefreshFromBlockHeightPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + int WOWNERO_Wallet_getRefreshFromBlockHeight( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getRefreshFromBlockHeight( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getRefreshFromBlockHeightPtr = + _lookup)>>( + 'WOWNERO_Wallet_getRefreshFromBlockHeight'); + late final _WOWNERO_Wallet_getRefreshFromBlockHeight = + _WOWNERO_Wallet_getRefreshFromBlockHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_setRecoveringFromSeed( + ffi.Pointer wallet_ptr, + bool recoveringFromSeed, + ) { + return _WOWNERO_Wallet_setRecoveringFromSeed( + wallet_ptr, + recoveringFromSeed, + ); + } + + late final _WOWNERO_Wallet_setRecoveringFromSeedPtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'WOWNERO_Wallet_setRecoveringFromSeed'); + late final _WOWNERO_Wallet_setRecoveringFromSeed = + _WOWNERO_Wallet_setRecoveringFromSeedPtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + void WOWNERO_Wallet_setRecoveringFromDevice( + ffi.Pointer wallet_ptr, + bool recoveringFromDevice, + ) { + return _WOWNERO_Wallet_setRecoveringFromDevice( + wallet_ptr, + recoveringFromDevice, + ); + } + + late final _WOWNERO_Wallet_setRecoveringFromDevicePtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'WOWNERO_Wallet_setRecoveringFromDevice'); + late final _WOWNERO_Wallet_setRecoveringFromDevice = + _WOWNERO_Wallet_setRecoveringFromDevicePtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + void WOWNERO_Wallet_setSubaddressLookahead( + ffi.Pointer 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.Uint32, + ffi.Uint32)>>('WOWNERO_Wallet_setSubaddressLookahead'); + late final _WOWNERO_Wallet_setSubaddressLookahead = + _WOWNERO_Wallet_setSubaddressLookaheadPtr.asFunction< + void Function(ffi.Pointer, int, int)>(); + + bool WOWNERO_Wallet_connectToDaemon( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_connectToDaemon( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_connectToDaemonPtr = + _lookup)>>( + 'WOWNERO_Wallet_connectToDaemon'); + late final _WOWNERO_Wallet_connectToDaemon = + _WOWNERO_Wallet_connectToDaemonPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_connected( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_connected( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_connectedPtr = + _lookup)>>( + 'WOWNERO_Wallet_connected'); + late final _WOWNERO_Wallet_connected = _WOWNERO_Wallet_connectedPtr + .asFunction)>(); + + void WOWNERO_Wallet_setTrustedDaemon( + ffi.Pointer wallet_ptr, + bool arg, + ) { + return _WOWNERO_Wallet_setTrustedDaemon( + wallet_ptr, + arg, + ); + } + + late final _WOWNERO_Wallet_setTrustedDaemonPtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'WOWNERO_Wallet_setTrustedDaemon'); + late final _WOWNERO_Wallet_setTrustedDaemon = + _WOWNERO_Wallet_setTrustedDaemonPtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + bool WOWNERO_Wallet_trustedDaemon( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_trustedDaemon( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_trustedDaemonPtr = + _lookup)>>( + 'WOWNERO_Wallet_trustedDaemon'); + late final _WOWNERO_Wallet_trustedDaemon = _WOWNERO_Wallet_trustedDaemonPtr + .asFunction)>(); + + bool WOWNERO_Wallet_setProxy( + ffi.Pointer wallet_ptr, + ffi.Pointer address, + ) { + return _WOWNERO_Wallet_setProxy( + wallet_ptr, + address, + ); + } + + late final _WOWNERO_Wallet_setProxyPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setProxy'); + late final _WOWNERO_Wallet_setProxy = _WOWNERO_Wallet_setProxyPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_Wallet_balance( + ffi.Pointer 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.Uint32)>>('WOWNERO_Wallet_balance'); + late final _WOWNERO_Wallet_balance = _WOWNERO_Wallet_balancePtr.asFunction< + int Function(ffi.Pointer, int)>(); + + int WOWNERO_Wallet_unlockedBalance( + ffi.Pointer 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.Uint32)>>('WOWNERO_Wallet_unlockedBalance'); + late final _WOWNERO_Wallet_unlockedBalance = + _WOWNERO_Wallet_unlockedBalancePtr.asFunction< + int Function(ffi.Pointer, int)>(); + + int WOWNERO_Wallet_viewOnlyBalance( + ffi.Pointer 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.Uint32)>>('WOWNERO_Wallet_viewOnlyBalance'); + late final _WOWNERO_Wallet_viewOnlyBalance = + _WOWNERO_Wallet_viewOnlyBalancePtr.asFunction< + int Function(ffi.Pointer, int)>(); + + bool WOWNERO_Wallet_watchOnly( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_watchOnly( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_watchOnlyPtr = + _lookup)>>( + 'WOWNERO_Wallet_watchOnly'); + late final _WOWNERO_Wallet_watchOnly = _WOWNERO_Wallet_watchOnlyPtr + .asFunction)>(); + + bool WOWNERO_Wallet_isDeterministic( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_isDeterministic( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_isDeterministicPtr = + _lookup)>>( + 'WOWNERO_Wallet_isDeterministic'); + late final _WOWNERO_Wallet_isDeterministic = + _WOWNERO_Wallet_isDeterministicPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_blockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_blockChainHeight( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_blockChainHeightPtr = + _lookup)>>( + 'WOWNERO_Wallet_blockChainHeight'); + late final _WOWNERO_Wallet_blockChainHeight = + _WOWNERO_Wallet_blockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_approximateBlockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_approximateBlockChainHeight( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_approximateBlockChainHeightPtr = + _lookup)>>( + 'WOWNERO_Wallet_approximateBlockChainHeight'); + late final _WOWNERO_Wallet_approximateBlockChainHeight = + _WOWNERO_Wallet_approximateBlockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_estimateBlockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_estimateBlockChainHeight( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_estimateBlockChainHeightPtr = + _lookup)>>( + 'WOWNERO_Wallet_estimateBlockChainHeight'); + late final _WOWNERO_Wallet_estimateBlockChainHeight = + _WOWNERO_Wallet_estimateBlockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_daemonBlockChainHeight( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_daemonBlockChainHeight( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_daemonBlockChainHeightPtr = + _lookup)>>( + 'WOWNERO_Wallet_daemonBlockChainHeight'); + late final _WOWNERO_Wallet_daemonBlockChainHeight = + _WOWNERO_Wallet_daemonBlockChainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_daemonBlockChainHeight_cached( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_daemonBlockChainHeight_cached( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr = + _lookup)>>( + 'WOWNERO_Wallet_daemonBlockChainHeight_cached'); + late final _WOWNERO_Wallet_daemonBlockChainHeight_cached = + _WOWNERO_Wallet_daemonBlockChainHeight_cachedPtr.asFunction< + int Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_daemonBlockChainHeight_runThread( + ffi.Pointer wallet_ptr, + int seconds, + ) { + return _WOWNERO_Wallet_daemonBlockChainHeight_runThread( + wallet_ptr, + seconds, + ); + } + + late final _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'WOWNERO_Wallet_daemonBlockChainHeight_runThread'); + late final _WOWNERO_Wallet_daemonBlockChainHeight_runThread = + _WOWNERO_Wallet_daemonBlockChainHeight_runThreadPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + int WOWNERO_Wallet_daemonBlockChainTargetHeight( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_daemonBlockChainTargetHeight( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_daemonBlockChainTargetHeightPtr = + _lookup)>>( + 'WOWNERO_Wallet_daemonBlockChainTargetHeight'); + late final _WOWNERO_Wallet_daemonBlockChainTargetHeight = + _WOWNERO_Wallet_daemonBlockChainTargetHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_synchronized( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_synchronized( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_synchronizedPtr = + _lookup)>>( + 'WOWNERO_Wallet_synchronized'); + late final _WOWNERO_Wallet_synchronized = _WOWNERO_Wallet_synchronizedPtr + .asFunction)>(); + + ffi.Pointer WOWNERO_Wallet_displayAmount( + int amount, + ) { + return _WOWNERO_Wallet_displayAmount( + amount, + ); + } + + late final _WOWNERO_Wallet_displayAmountPtr = + _lookup Function(ffi.Uint64)>>( + 'WOWNERO_Wallet_displayAmount'); + late final _WOWNERO_Wallet_displayAmount = _WOWNERO_Wallet_displayAmountPtr + .asFunction Function(int)>(); + + int WOWNERO_Wallet_amountFromString( + ffi.Pointer amount, + ) { + return _WOWNERO_Wallet_amountFromString( + amount, + ); + } + + late final _WOWNERO_Wallet_amountFromStringPtr = + _lookup)>>( + 'WOWNERO_Wallet_amountFromString'); + late final _WOWNERO_Wallet_amountFromString = + _WOWNERO_Wallet_amountFromStringPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_amountFromDouble( + double amount, + ) { + return _WOWNERO_Wallet_amountFromDouble( + amount, + ); + } + + late final _WOWNERO_Wallet_amountFromDoublePtr = + _lookup>( + 'WOWNERO_Wallet_amountFromDouble'); + late final _WOWNERO_Wallet_amountFromDouble = + _WOWNERO_Wallet_amountFromDoublePtr.asFunction(); + + ffi.Pointer WOWNERO_Wallet_genPaymentId() { + return _WOWNERO_Wallet_genPaymentId(); + } + + late final _WOWNERO_Wallet_genPaymentIdPtr = + _lookup Function()>>( + 'WOWNERO_Wallet_genPaymentId'); + late final _WOWNERO_Wallet_genPaymentId = _WOWNERO_Wallet_genPaymentIdPtr + .asFunction Function()>(); + + bool WOWNERO_Wallet_paymentIdValid( + ffi.Pointer paiment_id, + ) { + return _WOWNERO_Wallet_paymentIdValid( + paiment_id, + ); + } + + late final _WOWNERO_Wallet_paymentIdValidPtr = + _lookup)>>( + 'WOWNERO_Wallet_paymentIdValid'); + late final _WOWNERO_Wallet_paymentIdValid = _WOWNERO_Wallet_paymentIdValidPtr + .asFunction)>(); + + bool WOWNERO_Wallet_addressValid( + ffi.Pointer str, + int nettype, + ) { + return _WOWNERO_Wallet_addressValid( + str, + nettype, + ); + } + + late final _WOWNERO_Wallet_addressValidPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'WOWNERO_Wallet_addressValid'); + late final _WOWNERO_Wallet_addressValid = _WOWNERO_Wallet_addressValidPtr + .asFunction, int)>(); + + bool WOWNERO_Wallet_keyValid( + ffi.Pointer secret_key_string, + ffi.Pointer 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.Pointer, + ffi.Bool, ffi.Int)>>('WOWNERO_Wallet_keyValid'); + late final _WOWNERO_Wallet_keyValid = _WOWNERO_Wallet_keyValidPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool, int)>(); + + ffi.Pointer WOWNERO_Wallet_keyValid_error( + ffi.Pointer secret_key_string, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Int)>>('WOWNERO_Wallet_keyValid_error'); + late final _WOWNERO_Wallet_keyValid_error = + _WOWNERO_Wallet_keyValid_errorPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer, bool, int)>(); + + ffi.Pointer WOWNERO_Wallet_paymentIdFromAddress( + ffi.Pointer strarg, + int nettype, + ) { + return _WOWNERO_Wallet_paymentIdFromAddress( + strarg, + nettype, + ); + } + + late final _WOWNERO_Wallet_paymentIdFromAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Int)>>('WOWNERO_Wallet_paymentIdFromAddress'); + late final _WOWNERO_Wallet_paymentIdFromAddress = + _WOWNERO_Wallet_paymentIdFromAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int)>(); + + int WOWNERO_Wallet_maximumAllowedAmount() { + return _WOWNERO_Wallet_maximumAllowedAmount(); + } + + late final _WOWNERO_Wallet_maximumAllowedAmountPtr = + _lookup>( + 'WOWNERO_Wallet_maximumAllowedAmount'); + late final _WOWNERO_Wallet_maximumAllowedAmount = + _WOWNERO_Wallet_maximumAllowedAmountPtr.asFunction(); + + void WOWNERO_Wallet_init3( + ffi.Pointer wallet_ptr, + ffi.Pointer argv0, + ffi.Pointer default_log_base_name, + ffi.Pointer 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.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>('WOWNERO_Wallet_init3'); + late final _WOWNERO_Wallet_init3 = _WOWNERO_Wallet_init3Ptr.asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer, bool)>(); + + ffi.Pointer WOWNERO_Wallet_getPolyseed( + ffi.Pointer wallet_ptr, + ffi.Pointer passphrase, + ) { + return _WOWNERO_Wallet_getPolyseed( + wallet_ptr, + passphrase, + ); + } + + late final _WOWNERO_Wallet_getPolyseedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_getPolyseed'); + late final _WOWNERO_Wallet_getPolyseed = + _WOWNERO_Wallet_getPolyseedPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_createPolyseed( + ffi.Pointer language, + ) { + return _WOWNERO_Wallet_createPolyseed( + language, + ); + } + + late final _WOWNERO_Wallet_createPolyseedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_createPolyseed'); + late final _WOWNERO_Wallet_createPolyseed = _WOWNERO_Wallet_createPolyseedPtr + .asFunction Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_startRefresh( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_startRefresh( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_startRefreshPtr = + _lookup)>>( + 'WOWNERO_Wallet_startRefresh'); + late final _WOWNERO_Wallet_startRefresh = _WOWNERO_Wallet_startRefreshPtr + .asFunction)>(); + + void WOWNERO_Wallet_pauseRefresh( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_pauseRefresh( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_pauseRefreshPtr = + _lookup)>>( + 'WOWNERO_Wallet_pauseRefresh'); + late final _WOWNERO_Wallet_pauseRefresh = _WOWNERO_Wallet_pauseRefreshPtr + .asFunction)>(); + + bool WOWNERO_Wallet_refresh( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_refresh( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_refreshPtr = + _lookup)>>( + 'WOWNERO_Wallet_refresh'); + late final _WOWNERO_Wallet_refresh = _WOWNERO_Wallet_refreshPtr.asFunction< + bool Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_refreshAsync( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_refreshAsync( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_refreshAsyncPtr = + _lookup)>>( + 'WOWNERO_Wallet_refreshAsync'); + late final _WOWNERO_Wallet_refreshAsync = _WOWNERO_Wallet_refreshAsyncPtr + .asFunction)>(); + + bool WOWNERO_Wallet_rescanBlockchain( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_rescanBlockchain( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_rescanBlockchainPtr = + _lookup)>>( + 'WOWNERO_Wallet_rescanBlockchain'); + late final _WOWNERO_Wallet_rescanBlockchain = + _WOWNERO_Wallet_rescanBlockchainPtr.asFunction< + bool Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_rescanBlockchainAsync( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_rescanBlockchainAsync( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_rescanBlockchainAsyncPtr = + _lookup)>>( + 'WOWNERO_Wallet_rescanBlockchainAsync'); + late final _WOWNERO_Wallet_rescanBlockchainAsync = + _WOWNERO_Wallet_rescanBlockchainAsyncPtr.asFunction< + void Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_setAutoRefreshInterval( + ffi.Pointer wallet_ptr, + int millis, + ) { + return _WOWNERO_Wallet_setAutoRefreshInterval( + wallet_ptr, + millis, + ); + } + + late final _WOWNERO_Wallet_setAutoRefreshIntervalPtr = _lookup< + ffi + .NativeFunction, ffi.Int)>>( + 'WOWNERO_Wallet_setAutoRefreshInterval'); + late final _WOWNERO_Wallet_setAutoRefreshInterval = + _WOWNERO_Wallet_setAutoRefreshIntervalPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + int WOWNERO_Wallet_autoRefreshInterval( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_autoRefreshInterval( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_autoRefreshIntervalPtr = + _lookup)>>( + 'WOWNERO_Wallet_autoRefreshInterval'); + late final _WOWNERO_Wallet_autoRefreshInterval = + _WOWNERO_Wallet_autoRefreshIntervalPtr.asFunction< + int Function(ffi.Pointer)>(); + + void WOWNERO_Wallet_addSubaddressAccount( + ffi.Pointer wallet_ptr, + ffi.Pointer label, + ) { + return _WOWNERO_Wallet_addSubaddressAccount( + wallet_ptr, + label, + ); + } + + late final _WOWNERO_Wallet_addSubaddressAccountPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_addSubaddressAccount'); + late final _WOWNERO_Wallet_addSubaddressAccount = + _WOWNERO_Wallet_addSubaddressAccountPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_Wallet_numSubaddressAccounts( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_numSubaddressAccounts( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_numSubaddressAccountsPtr = + _lookup)>>( + 'WOWNERO_Wallet_numSubaddressAccounts'); + late final _WOWNERO_Wallet_numSubaddressAccounts = + _WOWNERO_Wallet_numSubaddressAccountsPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_numSubaddresses( + ffi.Pointer 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.Uint32)>>('WOWNERO_Wallet_numSubaddresses'); + late final _WOWNERO_Wallet_numSubaddresses = + _WOWNERO_Wallet_numSubaddressesPtr.asFunction< + int Function(ffi.Pointer, int)>(); + + void WOWNERO_Wallet_addSubaddress( + ffi.Pointer wallet_ptr, + int accountIndex, + ffi.Pointer label, + ) { + return _WOWNERO_Wallet_addSubaddress( + wallet_ptr, + accountIndex, + label, + ); + } + + late final _WOWNERO_Wallet_addSubaddressPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, + ffi.Pointer)>>('WOWNERO_Wallet_addSubaddress'); + late final _WOWNERO_Wallet_addSubaddress = + _WOWNERO_Wallet_addSubaddressPtr.asFunction< + void Function(ffi.Pointer, int, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getSubaddressLabel( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ) { + return _WOWNERO_Wallet_getSubaddressLabel( + wallet_ptr, + accountIndex, + addressIndex, + ); + } + + late final _WOWNERO_Wallet_getSubaddressLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, ffi.Uint32, + ffi.Uint32)>>('WOWNERO_Wallet_getSubaddressLabel'); + late final _WOWNERO_Wallet_getSubaddressLabel = + _WOWNERO_Wallet_getSubaddressLabelPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, int)>(); + + void WOWNERO_Wallet_setSubaddressLabel( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ffi.Pointer label, + ) { + return _WOWNERO_Wallet_setSubaddressLabel( + wallet_ptr, + accountIndex, + addressIndex, + label, + ); + } + + late final _WOWNERO_Wallet_setSubaddressLabelPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Uint32, ffi.Uint32, + ffi.Pointer)>>('WOWNERO_Wallet_setSubaddressLabel'); + late final _WOWNERO_Wallet_setSubaddressLabel = + _WOWNERO_Wallet_setSubaddressLabelPtr.asFunction< + void Function( + ffi.Pointer, int, int, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getMultisigInfo( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getMultisigInfo( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getMultisigInfoPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_getMultisigInfo'); + late final _WOWNERO_Wallet_getMultisigInfo = + _WOWNERO_Wallet_getMultisigInfoPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_createTransactionMultDest( + ffi.Pointer wallet_ptr, + ffi.Pointer dst_addr_list, + ffi.Pointer dst_addr_list_separator, + ffi.Pointer payment_id, + bool amount_sweep_all, + ffi.Pointer amount_list, + ffi.Pointer amount_list_separator, + int mixin_count, + int pendingTransactionPriority, + int subaddr_account, + ffi.Pointer preferredInputs, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer, + ffi.Pointer, + ffi.Uint32, + ffi.Int, + ffi.Uint32, + ffi.Pointer, + ffi.Pointer)>>( + 'WOWNERO_Wallet_createTransactionMultDest'); + late final _WOWNERO_Wallet_createTransactionMultDest = + _WOWNERO_Wallet_createTransactionMultDestPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_createTransaction( + ffi.Pointer wallet_ptr, + ffi.Pointer dst_addr, + ffi.Pointer payment_id, + int amount, + int mixin_count, + int pendingTransactionPriority, + int subaddr_account, + ffi.Pointer preferredInputs, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint64, + ffi.Uint32, + ffi.Int, + ffi.Uint32, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_createTransaction'); + late final _WOWNERO_Wallet_createTransaction = + _WOWNERO_Wallet_createTransactionPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + int, + ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_loadUnsignedTx( + ffi.Pointer wallet_ptr, + ffi.Pointer unsigned_filename, + ) { + return _WOWNERO_Wallet_loadUnsignedTx( + wallet_ptr, + unsigned_filename, + ); + } + + late final _WOWNERO_Wallet_loadUnsignedTxPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_loadUnsignedTx'); + late final _WOWNERO_Wallet_loadUnsignedTx = + _WOWNERO_Wallet_loadUnsignedTxPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_submitTransaction( + ffi.Pointer wallet_ptr, + ffi.Pointer fileName, + ) { + return _WOWNERO_Wallet_submitTransaction( + wallet_ptr, + fileName, + ); + } + + late final _WOWNERO_Wallet_submitTransactionPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_submitTransaction'); + late final _WOWNERO_Wallet_submitTransaction = + _WOWNERO_Wallet_submitTransactionPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_hasUnknownKeyImages( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_hasUnknownKeyImages( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_hasUnknownKeyImagesPtr = + _lookup)>>( + 'WOWNERO_Wallet_hasUnknownKeyImages'); + late final _WOWNERO_Wallet_hasUnknownKeyImages = + _WOWNERO_Wallet_hasUnknownKeyImagesPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_exportKeyImages( + ffi.Pointer wallet_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('WOWNERO_Wallet_exportKeyImages'); + late final _WOWNERO_Wallet_exportKeyImages = + _WOWNERO_Wallet_exportKeyImagesPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + bool WOWNERO_Wallet_importKeyImages( + ffi.Pointer wallet_ptr, + ffi.Pointer filename, + ) { + return _WOWNERO_Wallet_importKeyImages( + wallet_ptr, + filename, + ); + } + + late final _WOWNERO_Wallet_importKeyImagesPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_importKeyImages'); + late final _WOWNERO_Wallet_importKeyImages = + _WOWNERO_Wallet_importKeyImagesPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_exportOutputs( + ffi.Pointer wallet_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('WOWNERO_Wallet_exportOutputs'); + late final _WOWNERO_Wallet_exportOutputs = + _WOWNERO_Wallet_exportOutputsPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + bool WOWNERO_Wallet_importOutputs( + ffi.Pointer wallet_ptr, + ffi.Pointer filename, + ) { + return _WOWNERO_Wallet_importOutputs( + wallet_ptr, + filename, + ); + } + + late final _WOWNERO_Wallet_importOutputsPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_importOutputs'); + late final _WOWNERO_Wallet_importOutputs = + _WOWNERO_Wallet_importOutputsPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_setupBackgroundSync( + ffi.Pointer wallet_ptr, + int background_sync_type, + ffi.Pointer wallet_password, + ffi.Pointer 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.Int, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setupBackgroundSync'); + late final _WOWNERO_Wallet_setupBackgroundSync = + _WOWNERO_Wallet_setupBackgroundSyncPtr.asFunction< + bool Function(ffi.Pointer, int, ffi.Pointer, + ffi.Pointer)>(); + + int WOWNERO_Wallet_getBackgroundSyncType( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getBackgroundSyncType( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getBackgroundSyncTypePtr = + _lookup)>>( + 'WOWNERO_Wallet_getBackgroundSyncType'); + late final _WOWNERO_Wallet_getBackgroundSyncType = + _WOWNERO_Wallet_getBackgroundSyncTypePtr.asFunction< + int Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_startBackgroundSync( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_startBackgroundSync( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_startBackgroundSyncPtr = + _lookup)>>( + 'WOWNERO_Wallet_startBackgroundSync'); + late final _WOWNERO_Wallet_startBackgroundSync = + _WOWNERO_Wallet_startBackgroundSyncPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_stopBackgroundSync( + ffi.Pointer wallet_ptr, + ffi.Pointer wallet_password, + ) { + return _WOWNERO_Wallet_stopBackgroundSync( + wallet_ptr, + wallet_password, + ); + } + + late final _WOWNERO_Wallet_stopBackgroundSyncPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_stopBackgroundSync'); + late final _WOWNERO_Wallet_stopBackgroundSync = + _WOWNERO_Wallet_stopBackgroundSyncPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_isBackgroundSyncing( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_isBackgroundSyncing( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_isBackgroundSyncingPtr = + _lookup)>>( + 'WOWNERO_Wallet_isBackgroundSyncing'); + late final _WOWNERO_Wallet_isBackgroundSyncing = + _WOWNERO_Wallet_isBackgroundSyncingPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_Wallet_isBackgroundWallet( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_isBackgroundWallet( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_isBackgroundWalletPtr = + _lookup)>>( + 'WOWNERO_Wallet_isBackgroundWallet'); + late final _WOWNERO_Wallet_isBackgroundWallet = + _WOWNERO_Wallet_isBackgroundWalletPtr.asFunction< + bool Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_history( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_history( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_historyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_history'); + late final _WOWNERO_Wallet_history = _WOWNERO_Wallet_historyPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_addressBook( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_addressBook( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_addressBookPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_addressBook'); + late final _WOWNERO_Wallet_addressBook = _WOWNERO_Wallet_addressBookPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_coins( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_coins( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_coinsPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_coins'); + late final _WOWNERO_Wallet_coins = _WOWNERO_Wallet_coinsPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_subaddress( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_subaddress( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_subaddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_subaddress'); + late final _WOWNERO_Wallet_subaddress = _WOWNERO_Wallet_subaddressPtr + .asFunction Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_subaddressAccount( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_subaddressAccount( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_subaddressAccountPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_Wallet_subaddressAccount'); + late final _WOWNERO_Wallet_subaddressAccount = + _WOWNERO_Wallet_subaddressAccountPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_defaultMixin( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_defaultMixin( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_defaultMixinPtr = + _lookup)>>( + 'WOWNERO_Wallet_defaultMixin'); + late final _WOWNERO_Wallet_defaultMixin = _WOWNERO_Wallet_defaultMixinPtr + .asFunction)>(); + + void WOWNERO_Wallet_setDefaultMixin( + ffi.Pointer 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.Uint32)>>('WOWNERO_Wallet_setDefaultMixin'); + late final _WOWNERO_Wallet_setDefaultMixin = + _WOWNERO_Wallet_setDefaultMixinPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + bool WOWNERO_Wallet_setCacheAttribute( + ffi.Pointer wallet_ptr, + ffi.Pointer key, + ffi.Pointer val, + ) { + return _WOWNERO_Wallet_setCacheAttribute( + wallet_ptr, + key, + val, + ); + } + + late final _WOWNERO_Wallet_setCacheAttributePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setCacheAttribute'); + late final _WOWNERO_Wallet_setCacheAttribute = + _WOWNERO_Wallet_setCacheAttributePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getCacheAttribute( + ffi.Pointer wallet_ptr, + ffi.Pointer key, + ) { + return _WOWNERO_Wallet_getCacheAttribute( + wallet_ptr, + key, + ); + } + + late final _WOWNERO_Wallet_getCacheAttributePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_getCacheAttribute'); + late final _WOWNERO_Wallet_getCacheAttribute = + _WOWNERO_Wallet_getCacheAttributePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_setUserNote( + ffi.Pointer wallet_ptr, + ffi.Pointer txid, + ffi.Pointer note, + ) { + return _WOWNERO_Wallet_setUserNote( + wallet_ptr, + txid, + note, + ); + } + + late final _WOWNERO_Wallet_setUserNotePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_setUserNote'); + late final _WOWNERO_Wallet_setUserNote = + _WOWNERO_Wallet_setUserNotePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getUserNote( + ffi.Pointer wallet_ptr, + ffi.Pointer txid, + ) { + return _WOWNERO_Wallet_getUserNote( + wallet_ptr, + txid, + ); + } + + late final _WOWNERO_Wallet_getUserNotePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_getUserNote'); + late final _WOWNERO_Wallet_getUserNote = + _WOWNERO_Wallet_getUserNotePtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_getTxKey( + ffi.Pointer wallet_ptr, + ffi.Pointer txid, + ) { + return _WOWNERO_Wallet_getTxKey( + wallet_ptr, + txid, + ); + } + + late final _WOWNERO_Wallet_getTxKeyPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_getTxKey'); + late final _WOWNERO_Wallet_getTxKey = _WOWNERO_Wallet_getTxKeyPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_Wallet_signMessage( + ffi.Pointer wallet_ptr, + ffi.Pointer message, + ffi.Pointer address, + ) { + return _WOWNERO_Wallet_signMessage( + wallet_ptr, + message, + address, + ); + } + + late final _WOWNERO_Wallet_signMessagePtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_signMessage'); + late final _WOWNERO_Wallet_signMessage = + _WOWNERO_Wallet_signMessagePtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_verifySignedMessage( + ffi.Pointer wallet_ptr, + ffi.Pointer message, + ffi.Pointer address, + ffi.Pointer signature, + ) { + return _WOWNERO_Wallet_verifySignedMessage( + wallet_ptr, + message, + address, + signature, + ); + } + + late final _WOWNERO_Wallet_verifySignedMessagePtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_Wallet_verifySignedMessage'); + late final _WOWNERO_Wallet_verifySignedMessage = + _WOWNERO_Wallet_verifySignedMessagePtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_Wallet_rescanSpent( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_rescanSpent( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_rescanSpentPtr = + _lookup)>>( + 'WOWNERO_Wallet_rescanSpent'); + late final _WOWNERO_Wallet_rescanSpent = _WOWNERO_Wallet_rescanSpentPtr + .asFunction)>(); + + void WOWNERO_Wallet_setOffline( + ffi.Pointer wallet_ptr, + bool offline, + ) { + return _WOWNERO_Wallet_setOffline( + wallet_ptr, + offline, + ); + } + + late final _WOWNERO_Wallet_setOfflinePtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'WOWNERO_Wallet_setOffline'); + late final _WOWNERO_Wallet_setOffline = _WOWNERO_Wallet_setOfflinePtr + .asFunction, bool)>(); + + bool WOWNERO_Wallet_isOffline( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_isOffline( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_isOfflinePtr = + _lookup)>>( + 'WOWNERO_Wallet_isOffline'); + late final _WOWNERO_Wallet_isOffline = _WOWNERO_Wallet_isOfflinePtr + .asFunction)>(); + + void WOWNERO_Wallet_segregatePreForkOutputs( + ffi.Pointer wallet_ptr, + bool segregate, + ) { + return _WOWNERO_Wallet_segregatePreForkOutputs( + wallet_ptr, + segregate, + ); + } + + late final _WOWNERO_Wallet_segregatePreForkOutputsPtr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'WOWNERO_Wallet_segregatePreForkOutputs'); + late final _WOWNERO_Wallet_segregatePreForkOutputs = + _WOWNERO_Wallet_segregatePreForkOutputsPtr.asFunction< + void Function(ffi.Pointer, bool)>(); + + void WOWNERO_Wallet_segregationHeight( + ffi.Pointer 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.Uint64)>>('WOWNERO_Wallet_segregationHeight'); + late final _WOWNERO_Wallet_segregationHeight = + _WOWNERO_Wallet_segregationHeightPtr.asFunction< + void Function(ffi.Pointer, int)>(); + + void WOWNERO_Wallet_keyReuseMitigation2( + ffi.Pointer wallet_ptr, + bool mitigation, + ) { + return _WOWNERO_Wallet_keyReuseMitigation2( + wallet_ptr, + mitigation, + ); + } + + late final _WOWNERO_Wallet_keyReuseMitigation2Ptr = _lookup< + ffi + .NativeFunction, ffi.Bool)>>( + 'WOWNERO_Wallet_keyReuseMitigation2'); + late final _WOWNERO_Wallet_keyReuseMitigation2 = + _WOWNERO_Wallet_keyReuseMitigation2Ptr.asFunction< + void Function(ffi.Pointer, bool)>(); + + bool WOWNERO_Wallet_lockKeysFile( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_lockKeysFile( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_lockKeysFilePtr = + _lookup)>>( + 'WOWNERO_Wallet_lockKeysFile'); + late final _WOWNERO_Wallet_lockKeysFile = _WOWNERO_Wallet_lockKeysFilePtr + .asFunction)>(); + + bool WOWNERO_Wallet_unlockKeysFile( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_unlockKeysFile( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_unlockKeysFilePtr = + _lookup)>>( + 'WOWNERO_Wallet_unlockKeysFile'); + late final _WOWNERO_Wallet_unlockKeysFile = _WOWNERO_Wallet_unlockKeysFilePtr + .asFunction)>(); + + bool WOWNERO_Wallet_isKeysFileLocked( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_isKeysFileLocked( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_isKeysFileLockedPtr = + _lookup)>>( + 'WOWNERO_Wallet_isKeysFileLocked'); + late final _WOWNERO_Wallet_isKeysFileLocked = + _WOWNERO_Wallet_isKeysFileLockedPtr.asFunction< + bool Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_getDeviceType( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getDeviceType( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getDeviceTypePtr = + _lookup)>>( + 'WOWNERO_Wallet_getDeviceType'); + late final _WOWNERO_Wallet_getDeviceType = _WOWNERO_Wallet_getDeviceTypePtr + .asFunction)>(); + + int WOWNERO_Wallet_coldKeyImageSync( + ffi.Pointer 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.Uint64, + ffi.Uint64)>>('WOWNERO_Wallet_coldKeyImageSync'); + late final _WOWNERO_Wallet_coldKeyImageSync = + _WOWNERO_Wallet_coldKeyImageSyncPtr.asFunction< + int Function(ffi.Pointer, int, int)>(); + + ffi.Pointer WOWNERO_Wallet_deviceShowAddress( + ffi.Pointer wallet_ptr, + int accountIndex, + int addressIndex, + ) { + return _WOWNERO_Wallet_deviceShowAddress( + wallet_ptr, + accountIndex, + addressIndex, + ); + } + + late final _WOWNERO_Wallet_deviceShowAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, ffi.Uint32, + ffi.Uint32)>>('WOWNERO_Wallet_deviceShowAddress'); + late final _WOWNERO_Wallet_deviceShowAddress = + _WOWNERO_Wallet_deviceShowAddressPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, int, int)>(); + + bool WOWNERO_Wallet_reconnectDevice( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_reconnectDevice( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_reconnectDevicePtr = + _lookup)>>( + 'WOWNERO_Wallet_reconnectDevice'); + late final _WOWNERO_Wallet_reconnectDevice = + _WOWNERO_Wallet_reconnectDevicePtr.asFunction< + bool Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_getBytesReceived( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getBytesReceived( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getBytesReceivedPtr = + _lookup)>>( + 'WOWNERO_Wallet_getBytesReceived'); + late final _WOWNERO_Wallet_getBytesReceived = + _WOWNERO_Wallet_getBytesReceivedPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_Wallet_getBytesSent( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_Wallet_getBytesSent( + wallet_ptr, + ); + } + + late final _WOWNERO_Wallet_getBytesSentPtr = + _lookup)>>( + 'WOWNERO_Wallet_getBytesSent'); + late final _WOWNERO_Wallet_getBytesSent = _WOWNERO_Wallet_getBytesSentPtr + .asFunction)>(); + + ffi.Pointer WOWNERO_WalletManager_createWallet( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int networkType, + ) { + return _WOWNERO_WalletManager_createWallet( + wm_ptr, + path, + password, + language, + networkType, + ); + } + + late final _WOWNERO_WalletManager_createWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int)>>('WOWNERO_WalletManager_createWallet'); + late final _WOWNERO_WalletManager_createWallet = + _WOWNERO_WalletManager_createWalletPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + + ffi.Pointer WOWNERO_WalletManager_openWallet( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + int networkType, + ) { + return _WOWNERO_WalletManager_openWallet( + wm_ptr, + path, + password, + networkType, + ); + } + + late final _WOWNERO_WalletManager_openWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int)>>('WOWNERO_WalletManager_openWallet'); + late final _WOWNERO_WalletManager_openWallet = + _WOWNERO_WalletManager_openWalletPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); + + ffi.Pointer WOWNERO_WalletManager_recoveryWallet( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer mnemonic, + int networkType, + int restoreHeight, + int kdfRounds, + ffi.Pointer seedOffset, + ) { + return _WOWNERO_WalletManager_recoveryWallet( + wm_ptr, + path, + password, + mnemonic, + networkType, + restoreHeight, + kdfRounds, + seedOffset, + ); + } + + late final _WOWNERO_WalletManager_recoveryWalletPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Uint64, + ffi.Uint64, + ffi.Pointer)>>('WOWNERO_WalletManager_recoveryWallet'); + late final _WOWNERO_WalletManager_recoveryWallet = + _WOWNERO_WalletManager_recoveryWalletPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + ffi.Pointer WOWNERO_WalletManager_createWalletFromKeys( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int nettype, + int restoreHeight, + ffi.Pointer addressString, + ffi.Pointer viewKeyString, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Uint64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint64)>>('WOWNERO_WalletManager_createWalletFromKeys'); + late final _WOWNERO_WalletManager_createWalletFromKeys = + _WOWNERO_WalletManager_createWalletFromKeysPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + + ffi.Pointer + WOWNERO_WalletManager_createDeterministicWalletFromSpendKey( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int nettype, + int restoreHeight, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Uint64, + ffi.Pointer, + ffi.Uint64)>>( + 'WOWNERO_WalletManager_createDeterministicWalletFromSpendKey'); + late final _WOWNERO_WalletManager_createDeterministicWalletFromSpendKey = + _WOWNERO_WalletManager_createDeterministicWalletFromSpendKeyPtr + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer, + int)>(); + + ffi.Pointer WOWNERO_WalletManager_createWalletFromPolyseed( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer password, + int nettype, + ffi.Pointer mnemonic, + ffi.Pointer 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 Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Uint64, + ffi.Uint64)>>('WOWNERO_WalletManager_createWalletFromPolyseed'); + late final _WOWNERO_WalletManager_createWalletFromPolyseed = + _WOWNERO_WalletManager_createWalletFromPolyseedPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + bool, + int, + int)>(); + + bool WOWNERO_WalletManager_closeWallet( + ffi.Pointer wm_ptr, + ffi.Pointer 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.Pointer, + ffi.Bool)>>('WOWNERO_WalletManager_closeWallet'); + late final _WOWNERO_WalletManager_closeWallet = + _WOWNERO_WalletManager_closeWalletPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, bool)>(); + + bool WOWNERO_WalletManager_walletExists( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ) { + return _WOWNERO_WalletManager_walletExists( + wm_ptr, + path, + ); + } + + late final _WOWNERO_WalletManager_walletExistsPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_WalletManager_walletExists'); + late final _WOWNERO_WalletManager_walletExists = + _WOWNERO_WalletManager_walletExistsPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + bool WOWNERO_WalletManager_verifyWalletPassword( + ffi.Pointer wm_ptr, + ffi.Pointer keys_file_name, + ffi.Pointer 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.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Uint64)>>('WOWNERO_WalletManager_verifyWalletPassword'); + late final _WOWNERO_WalletManager_verifyWalletPassword = + _WOWNERO_WalletManager_verifyWalletPasswordPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, bool, int)>(); + + ffi.Pointer WOWNERO_WalletManager_findWallets( + ffi.Pointer wm_ptr, + ffi.Pointer path, + ffi.Pointer separator, + ) { + return _WOWNERO_WalletManager_findWallets( + wm_ptr, + path, + separator, + ); + } + + late final _WOWNERO_WalletManager_findWalletsPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('WOWNERO_WalletManager_findWallets'); + late final _WOWNERO_WalletManager_findWallets = + _WOWNERO_WalletManager_findWalletsPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_WalletManager_errorString( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_errorString( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_errorStringPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_WalletManager_errorString'); + late final _WOWNERO_WalletManager_errorString = + _WOWNERO_WalletManager_errorStringPtr.asFunction< + ffi.Pointer Function(ffi.Pointer)>(); + + void WOWNERO_WalletManager_setDaemonAddress( + ffi.Pointer wm_ptr, + ffi.Pointer address, + ) { + return _WOWNERO_WalletManager_setDaemonAddress( + wm_ptr, + address, + ); + } + + late final _WOWNERO_WalletManager_setDaemonAddressPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer)>>( + 'WOWNERO_WalletManager_setDaemonAddress'); + late final _WOWNERO_WalletManager_setDaemonAddress = + _WOWNERO_WalletManager_setDaemonAddressPtr.asFunction< + void Function(ffi.Pointer, ffi.Pointer)>(); + + int WOWNERO_WalletManager_blockchainHeight( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_blockchainHeight( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_blockchainHeightPtr = + _lookup)>>( + 'WOWNERO_WalletManager_blockchainHeight'); + late final _WOWNERO_WalletManager_blockchainHeight = + _WOWNERO_WalletManager_blockchainHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_WalletManager_blockchainTargetHeight( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_blockchainTargetHeight( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_blockchainTargetHeightPtr = + _lookup)>>( + 'WOWNERO_WalletManager_blockchainTargetHeight'); + late final _WOWNERO_WalletManager_blockchainTargetHeight = + _WOWNERO_WalletManager_blockchainTargetHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + int WOWNERO_WalletManager_networkDifficulty( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_networkDifficulty( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_networkDifficultyPtr = + _lookup)>>( + 'WOWNERO_WalletManager_networkDifficulty'); + late final _WOWNERO_WalletManager_networkDifficulty = + _WOWNERO_WalletManager_networkDifficultyPtr.asFunction< + int Function(ffi.Pointer)>(); + + double WOWNERO_WalletManager_miningHashRate( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_miningHashRate( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_miningHashRatePtr = + _lookup)>>( + 'WOWNERO_WalletManager_miningHashRate'); + late final _WOWNERO_WalletManager_miningHashRate = + _WOWNERO_WalletManager_miningHashRatePtr.asFunction< + double Function(ffi.Pointer)>(); + + int WOWNERO_WalletManager_blockTarget( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_blockTarget( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_blockTargetPtr = + _lookup)>>( + 'WOWNERO_WalletManager_blockTarget'); + late final _WOWNERO_WalletManager_blockTarget = + _WOWNERO_WalletManager_blockTargetPtr.asFunction< + int Function(ffi.Pointer)>(); + + bool WOWNERO_WalletManager_isMining( + ffi.Pointer wm_ptr, + ) { + return _WOWNERO_WalletManager_isMining( + wm_ptr, + ); + } + + late final _WOWNERO_WalletManager_isMiningPtr = + _lookup)>>( + 'WOWNERO_WalletManager_isMining'); + late final _WOWNERO_WalletManager_isMining = + _WOWNERO_WalletManager_isMiningPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_WalletManager_startMining( + ffi.Pointer wm_ptr, + ffi.Pointer 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.Pointer, + ffi.Uint32, + ffi.Bool, + ffi.Bool)>>('WOWNERO_WalletManager_startMining'); + late final _WOWNERO_WalletManager_startMining = + _WOWNERO_WalletManager_startMiningPtr.asFunction< + bool Function( + ffi.Pointer, ffi.Pointer, int, bool, bool)>(); + + bool WOWNERO_WalletManager_stopMining( + ffi.Pointer wm_ptr, + ffi.Pointer address, + ) { + return _WOWNERO_WalletManager_stopMining( + wm_ptr, + address, + ); + } + + late final _WOWNERO_WalletManager_stopMiningPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_WalletManager_stopMining'); + late final _WOWNERO_WalletManager_stopMining = + _WOWNERO_WalletManager_stopMiningPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_WalletManager_resolveOpenAlias( + ffi.Pointer wm_ptr, + ffi.Pointer address, + bool dnssec_valid, + ) { + return _WOWNERO_WalletManager_resolveOpenAlias( + wm_ptr, + address, + dnssec_valid, + ); + } + + late final _WOWNERO_WalletManager_resolveOpenAliasPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>('WOWNERO_WalletManager_resolveOpenAlias'); + late final _WOWNERO_WalletManager_resolveOpenAlias = + _WOWNERO_WalletManager_resolveOpenAliasPtr.asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer, bool)>(); + + bool WOWNERO_WalletManager_setProxy( + ffi.Pointer wm_ptr, + ffi.Pointer address, + ) { + return _WOWNERO_WalletManager_setProxy( + wm_ptr, + address, + ); + } + + late final _WOWNERO_WalletManager_setProxyPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>('WOWNERO_WalletManager_setProxy'); + late final _WOWNERO_WalletManager_setProxy = + _WOWNERO_WalletManager_setProxyPtr.asFunction< + bool Function(ffi.Pointer, ffi.Pointer)>(); + + ffi.Pointer WOWNERO_WalletManagerFactory_getWalletManager() { + return _WOWNERO_WalletManagerFactory_getWalletManager(); + } + + late final _WOWNERO_WalletManagerFactory_getWalletManagerPtr = + _lookup Function()>>( + 'WOWNERO_WalletManagerFactory_getWalletManager'); + late final _WOWNERO_WalletManagerFactory_getWalletManager = + _WOWNERO_WalletManagerFactory_getWalletManagerPtr.asFunction< + ffi.Pointer Function()>(); + + void WOWNERO_WalletManagerFactory_setLogLevel( + int level, + ) { + return _WOWNERO_WalletManagerFactory_setLogLevel( + level, + ); + } + + late final _WOWNERO_WalletManagerFactory_setLogLevelPtr = + _lookup>( + 'WOWNERO_WalletManagerFactory_setLogLevel'); + late final _WOWNERO_WalletManagerFactory_setLogLevel = + _WOWNERO_WalletManagerFactory_setLogLevelPtr.asFunction< + void Function(int)>(); + + void WOWNERO_WalletManagerFactory_setLogCategories( + ffi.Pointer categories, + ) { + return _WOWNERO_WalletManagerFactory_setLogCategories( + categories, + ); + } + + late final _WOWNERO_WalletManagerFactory_setLogCategoriesPtr = + _lookup)>>( + 'WOWNERO_WalletManagerFactory_setLogCategories'); + late final _WOWNERO_WalletManagerFactory_setLogCategories = + _WOWNERO_WalletManagerFactory_setLogCategoriesPtr.asFunction< + void Function(ffi.Pointer)>(); + + void WOWNERO_DEBUG_test0() { + return _WOWNERO_DEBUG_test0(); + } + + late final _WOWNERO_DEBUG_test0Ptr = + _lookup>('WOWNERO_DEBUG_test0'); + late final _WOWNERO_DEBUG_test0 = + _WOWNERO_DEBUG_test0Ptr.asFunction(); + + bool WOWNERO_DEBUG_test1( + bool x, + ) { + return _WOWNERO_DEBUG_test1( + x, + ); + } + + late final _WOWNERO_DEBUG_test1Ptr = + _lookup>( + 'WOWNERO_DEBUG_test1'); + late final _WOWNERO_DEBUG_test1 = + _WOWNERO_DEBUG_test1Ptr.asFunction(); + + int WOWNERO_DEBUG_test2( + int x, + ) { + return _WOWNERO_DEBUG_test2( + x, + ); + } + + late final _WOWNERO_DEBUG_test2Ptr = + _lookup>( + 'WOWNERO_DEBUG_test2'); + late final _WOWNERO_DEBUG_test2 = + _WOWNERO_DEBUG_test2Ptr.asFunction(); + + int WOWNERO_DEBUG_test3( + int x, + ) { + return _WOWNERO_DEBUG_test3( + x, + ); + } + + late final _WOWNERO_DEBUG_test3Ptr = + _lookup>( + 'WOWNERO_DEBUG_test3'); + late final _WOWNERO_DEBUG_test3 = + _WOWNERO_DEBUG_test3Ptr.asFunction(); + + ffi.Pointer WOWNERO_DEBUG_test4( + int x, + ) { + return _WOWNERO_DEBUG_test4( + x, + ); + } + + late final _WOWNERO_DEBUG_test4Ptr = + _lookup Function(ffi.Uint64)>>( + 'WOWNERO_DEBUG_test4'); + late final _WOWNERO_DEBUG_test4 = + _WOWNERO_DEBUG_test4Ptr.asFunction Function(int)>(); + + ffi.Pointer WOWNERO_DEBUG_test5() { + return _WOWNERO_DEBUG_test5(); + } + + late final _WOWNERO_DEBUG_test5Ptr = + _lookup Function()>>( + 'WOWNERO_DEBUG_test5'); + late final _WOWNERO_DEBUG_test5 = + _WOWNERO_DEBUG_test5Ptr.asFunction Function()>(); + + ffi.Pointer WOWNERO_DEBUG_test5_std() { + return _WOWNERO_DEBUG_test5_std(); + } + + late final _WOWNERO_DEBUG_test5_stdPtr = + _lookup Function()>>( + 'WOWNERO_DEBUG_test5_std'); + late final _WOWNERO_DEBUG_test5_std = _WOWNERO_DEBUG_test5_stdPtr.asFunction< + ffi.Pointer Function()>(); + + bool WOWNERO_DEBUG_isPointerNull( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_DEBUG_isPointerNull( + wallet_ptr, + ); + } + + late final _WOWNERO_DEBUG_isPointerNullPtr = + _lookup)>>( + 'WOWNERO_DEBUG_isPointerNull'); + late final _WOWNERO_DEBUG_isPointerNull = _WOWNERO_DEBUG_isPointerNullPtr + .asFunction)>(); + + ffi.Pointer WOWNERO_cw_getWalletListener( + ffi.Pointer wallet_ptr, + ) { + return _WOWNERO_cw_getWalletListener( + wallet_ptr, + ); + } + + late final _WOWNERO_cw_getWalletListenerPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer)>>('WOWNERO_cw_getWalletListener'); + late final _WOWNERO_cw_getWalletListener = _WOWNERO_cw_getWalletListenerPtr + .asFunction Function(ffi.Pointer)>(); + + void WOWNERO_cw_WalletListener_resetNeedToRefresh( + ffi.Pointer cw_walletListener_ptr, + ) { + return _WOWNERO_cw_WalletListener_resetNeedToRefresh( + cw_walletListener_ptr, + ); + } + + late final _WOWNERO_cw_WalletListener_resetNeedToRefreshPtr = + _lookup)>>( + 'WOWNERO_cw_WalletListener_resetNeedToRefresh'); + late final _WOWNERO_cw_WalletListener_resetNeedToRefresh = + _WOWNERO_cw_WalletListener_resetNeedToRefreshPtr.asFunction< + void Function(ffi.Pointer)>(); + + bool WOWNERO_cw_WalletListener_isNeedToRefresh( + ffi.Pointer cw_walletListener_ptr, + ) { + return _WOWNERO_cw_WalletListener_isNeedToRefresh( + cw_walletListener_ptr, + ); + } + + late final _WOWNERO_cw_WalletListener_isNeedToRefreshPtr = + _lookup)>>( + 'WOWNERO_cw_WalletListener_isNeedToRefresh'); + late final _WOWNERO_cw_WalletListener_isNeedToRefresh = + _WOWNERO_cw_WalletListener_isNeedToRefreshPtr.asFunction< + bool Function(ffi.Pointer)>(); + + bool WOWNERO_cw_WalletListener_isNewTransactionExist( + ffi.Pointer cw_walletListener_ptr, + ) { + return _WOWNERO_cw_WalletListener_isNewTransactionExist( + cw_walletListener_ptr, + ); + } + + late final _WOWNERO_cw_WalletListener_isNewTransactionExistPtr = + _lookup)>>( + 'WOWNERO_cw_WalletListener_isNewTransactionExist'); + late final _WOWNERO_cw_WalletListener_isNewTransactionExist = + _WOWNERO_cw_WalletListener_isNewTransactionExistPtr.asFunction< + bool Function(ffi.Pointer)>(); + + void WOWNERO_cw_WalletListener_resetIsNewTransactionExist( + ffi.Pointer cw_walletListener_ptr, + ) { + return _WOWNERO_cw_WalletListener_resetIsNewTransactionExist( + cw_walletListener_ptr, + ); + } + + late final _WOWNERO_cw_WalletListener_resetIsNewTransactionExistPtr = + _lookup)>>( + 'WOWNERO_cw_WalletListener_resetIsNewTransactionExist'); + late final _WOWNERO_cw_WalletListener_resetIsNewTransactionExist = + _WOWNERO_cw_WalletListener_resetIsNewTransactionExistPtr.asFunction< + void Function(ffi.Pointer)>(); + + int WOWNERO_cw_WalletListener_height( + ffi.Pointer cw_walletListener_ptr, + ) { + return _WOWNERO_cw_WalletListener_height( + cw_walletListener_ptr, + ); + } + + late final _WOWNERO_cw_WalletListener_heightPtr = + _lookup)>>( + 'WOWNERO_cw_WalletListener_height'); + late final _WOWNERO_cw_WalletListener_height = + _WOWNERO_cw_WalletListener_heightPtr.asFunction< + int Function(ffi.Pointer)>(); + + ffi.Pointer WOWNERO_deprecated_restore14WordSeed( + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer seed, + int networkType, + ) { + return _WOWNERO_deprecated_restore14WordSeed( + path, + password, + seed, + networkType, + ); + } + + late final _WOWNERO_deprecated_restore14WordSeedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int32)>>('WOWNERO_deprecated_restore14WordSeed'); + late final _WOWNERO_deprecated_restore14WordSeed = + _WOWNERO_deprecated_restore14WordSeedPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); + + ffi.Pointer WOWNERO_deprecated_create14WordSeed( + ffi.Pointer path, + ffi.Pointer password, + ffi.Pointer language, + int networkType, + ) { + return _WOWNERO_deprecated_create14WordSeed( + path, + password, + language, + networkType, + ); + } + + late final _WOWNERO_deprecated_create14WordSeedPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int32)>>('WOWNERO_deprecated_create14WordSeed'); + late final _WOWNERO_deprecated_create14WordSeed = + _WOWNERO_deprecated_create14WordSeedPtr.asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); + + int WOWNERO_deprecated_14WordSeedHeight( + ffi.Pointer seed, + ) { + return _WOWNERO_deprecated_14WordSeedHeight( + seed, + ); + } + + late final _WOWNERO_deprecated_14WordSeedHeightPtr = + _lookup)>>( + 'WOWNERO_deprecated_14WordSeedHeight'); + late final _WOWNERO_deprecated_14WordSeedHeight = + _WOWNERO_deprecated_14WordSeedHeightPtr.asFunction< + int Function(ffi.Pointer)>(); + + void WOWNERO_free( + ffi.Pointer ptr, + ) { + return _WOWNERO_free( + ptr, + ); + } + + late final _WOWNERO_freePtr = + _lookup)>>( + 'WOWNERO_free'); + late final _WOWNERO_free = + _WOWNERO_freePtr.asFunction)>(); +} diff --git a/impls/monero.dart/lib/wownero.dart b/impls/monero.dart/lib/wownero.dart new file mode 100644 index 00000000..2f9252dc --- /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 (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 +// {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 preferredInputs = const []}) { List - 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(); -----------------| Cast the strings into Chars so it can be used as a parameter in a function | +// final payment_id_ = payment_id.toNativeUtf8().cast(); -------------| generated via ffigen | +// final preferredInputs_ = preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast(); <---------------------------------------------------------/ +// 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(); +// 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(); 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; + +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> debugCallLength = {}; + +final defaultSeparatorStr = ";"; +final defaultSeparator = defaultSeparatorStr.toNativeUtf8().cast(); +/* 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] ??= []; + 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(); + 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(); + 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(); + final txid = lib!.WOWNERO_PendingTransaction_txid(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('WOWNERO_PendingTransaction_txid'); + try { + final strPtr = txid.cast(); + 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(); + final txid = lib!.WOWNERO_PendingTransaction_subaddrAccount(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('WOWNERO_PendingTransaction_subaddrAccount'); + try { + final strPtr = txid.cast(); + 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(); + final txid = lib!.WOWNERO_PendingTransaction_subaddrIndices(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('WOWNERO_PendingTransaction_subaddrIndices'); + try { + final strPtr = txid.cast(); + 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(); + 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(); + final txid = lib!.WOWNERO_PendingTransaction_signersKeys(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('WOWNERO_PendingTransaction_signersKeys'); + try { + final strPtr = txid.cast(); + 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(); + final txid = lib!.WOWNERO_PendingTransaction_hex(ptr, separator_); + calloc.free(separator_); + debugEnd?.call('WOWNERO_PendingTransaction_hex'); + try { + final strPtr = txid.cast(); + 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; + +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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final v = lib!.WOWNERO_UnsignedTransaction_sign(ptr, signedFileName_); + calloc.free(signedFileName_); + debugStart?.call('WOWNERO_UnsignedTransaction_sign'); + return v; +} +// TransactionInfo + +typedef TransactionInfo = Pointer; + +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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + final note_ = note.toNativeUtf8().cast(); + 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; + +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(); + 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(); + 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(); + 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(); + 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; + +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(); + final payment_id_ = paymentId.toNativeUtf8().cast(); + final description_ = description.toNativeUtf8().cast(); + 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(); + 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(); + final v = + lib!.WOWNERO_AddressBook_lookupPaymentID(addressBook_ptr, paymentId_); + calloc.free(paymentId_); + debugEnd?.call('WOWNERO_AddressBook_lookupPaymentID'); + return v; +} + +// CoinsInfo +typedef CoinsInfo = Pointer; + +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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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; + +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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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(); + final status = lib!.WOWNERO_Subaddress_refresh(ptr, accountIndex); + calloc.free(label_); + debugEnd?.call('WOWNERO_Subaddress_refresh'); + return status; +} + +typedef SubaddressAccountRow = Pointer; + +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(); + 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(); + 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(); + 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(); + 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(); + 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; + +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(); + 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(); + 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; + +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; + +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; + +String Wallet_seed(wallet ptr, {required String seedOffset}) { + debugStart?.call('WOWNERO_Wallet_seed'); + lib ??= WowneroC(DynamicLibrary.open(libPath)); + try { + final seedOffset_ = seedOffset.toNativeUtf8().cast(); + final strPtr = lib!.WOWNERO_Wallet_seed(ptr, seedOffset_).cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final strPtr = + lib!.WOWNERO_Wallet_integratedAddress(ptr, paymentId_).cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final daemonUsername_ = daemonUsername.toNativeUtf8().cast(); + final daemonPassword_ = daemonPassword.toNativeUtf8().cast(); + final proxyAddress_ = proxyAddress.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final address_string_ = address_string.toNativeUtf8().cast(); + 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(); + final address_string_ = address_string.toNativeUtf8().cast(); + final strPtr = lib! + .WOWNERO_Wallet_keyValid_error( + secret_key_string_, address_string_, isViewKey, nettype) + .cast(); + 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(); + final strPtr = + lib!.WOWNERO_Wallet_paymentIdFromAddress(strarg_, nettype).cast(); + 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(); + final defaultLogBaseName_ = defaultLogBaseName.toNativeUtf8().cast(); + final logPath_ = logPath.toNativeUtf8().cast(); + 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(); + final strPtr = + lib!.WOWNERO_Wallet_getPolyseed(ptr, passphrase_).cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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 dstAddr, + String paymentId = "", + required bool isSweepAll, + required List amounts, + required int mixinCount, + required int pendingTransactionPriority, + required int subaddr_account, + List 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 preferredInputs = const []}) { + debugStart?.call('WOWNERO_Wallet_createTransaction'); + lib ??= WowneroC(DynamicLibrary.open(libPath)); + + final dst_addr_ = dst_addr.toNativeUtf8().cast(); + final payment_id_ = payment_id.toNativeUtf8().cast(); + final preferredInputs_ = + preferredInputs.join(defaultSeparatorStr).toNativeUtf8().cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + final backgroundCachePassword_ = + backgroundCachePassword.toNativeUtf8().cast(); + 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(); + 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(); + final value_ = value.toNativeUtf8().cast(); + 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(); + final strPtr = + lib!.WOWNERO_Wallet_getCacheAttribute(ptr, key_).cast(); + 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(); + final note_ = note.toNativeUtf8().cast(); + 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(); + final strPtr = lib!.WOWNERO_Wallet_getUserNote(ptr, txid_).cast(); + 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(); + final strPtr = lib!.WOWNERO_Wallet_getTxKey(ptr, txid_).cast(); + 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(); + final address_ = address.toNativeUtf8().cast(); + final strPtr = + lib!.WOWNERO_Wallet_signMessage(ptr, message_, address_).cast(); + 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(); + final address_ = address.toNativeUtf8().cast(); + final signature_ = signature.toNativeUtf8().cast(); + 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(); + 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; + +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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final mnemonic_ = mnemonic.toNativeUtf8().cast(); + final seedOffset_ = seedOffset.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + final addressString_ = addressString.toNativeUtf8().cast(); + final viewKeyString_ = viewKeyString.toNativeUtf8().cast(); + final spendKeyString_ = spendKeyString.toNativeUtf8().cast(); + + 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(); + final password_ = password.toNativeUtf8().cast(); + final language_ = language.toNativeUtf8().cast(); + final spendKeyString_ = spendKeyString.toNativeUtf8().cast(); + 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(); + final password_ = password.toNativeUtf8().cast(); + final mnemonic_ = mnemonic.toNativeUtf8().cast(); + final seedOffset_ = seedOffset.toNativeUtf8().cast(); + 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(); + 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(); + final password_ = password.toNativeUtf8().cast(); + 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(); + final strPtr = lib! + .WOWNERO_WalletManager_findWallets(wm_ptr, path_, defaultSeparator) + .cast(); + 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(); + 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(); + 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(); + 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(); + 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(); + final strPtr = lib! + .WOWNERO_WalletManager_resolveOpenAlias(wm_ptr, address_, dnssecValid) + .cast(); + 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(); + 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(); + 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 test4; + final Pointer test5; + String get test5_str { + try { + return test5.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + String get test5_str16 { + try { + return test5.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + final Pointer test5_std; + String get test5_std_str { + try { + return test5_std.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + String get test5_std_str16 { + try { + return test5_std.cast().toDartString(); + } catch (e) { + return "$e"; + } + } + + Map 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; + +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 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 00000000..21162b9d --- /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 00000000..4f48698c --- /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 00000000..8ac3cabc --- /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 00000000..3dfff5cf --- /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